static BOOL set_component( WCHAR **str, DWORD *str_len, WCHAR *value, DWORD len, DWORD flags )
{
if (*str && !*str_len)
{
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
}
if (!*str_len) return TRUE;
if (!*str)
{
if (len && *str_len && (flags & (ICU_DECODE|ICU_ESCAPE)))
{
set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
}
*str = value;
*str_len = len;
}
else
{
if (len > (*str_len) - 1)
{
*str_len = len + 1;
set_last_error( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
memcpy( *str, value, len * sizeof(WCHAR) );
(*str)[len] = 0;
*str_len = len;
}
return TRUE;
}
int check_segd_option(char_t const* option/*, char const* option_value, unsigned option_value_size*/)
{
int i_ret = APP_FAULT;
int i = 0;
size_t size = 0;
char tmp_buf[MAX_STRING_SIZE*2] = {0};
errno_t err_code = 0x0;
#if defined(UNICODE) || defined(_UNICODE)
err_code = wcstombs_s(&size, tmp_buf, sizeof(tmp_buf), option, MAX_STRING_SIZE);
if(err_code != 0){
set_last_error(IDS_STRING5010);
output_log(IDS_STRING5010, option);
return i_ret;
}
tmp_buf[size] = 0x0;
#else
strcpy(tmp_buf, option, strlen(option) + 1);
#endif //defined(UNICODE) || defined(_UNICODE)
size = sizeof(__segd_option_items)/sizeof(__segd_option_items[0]);
for(i = 0; i < size; ++i){
if(_stricmp(tmp_buf, __segd_option_items[i].key_name_) == 0)
{ i_ret = APP_SUCCESS; break; }
}
if(i_ret != APP_SUCCESS){
set_last_error(IDS_STRING5009);
output_log(IDS_STRING5009, option);
}
return i_ret;
}
Status PreludeScript::try_run()
{
v8::Context::Scope context_scope(get_context());
global_template_factory.reset();
if (!enter_cancellable_region())
return S_TERMINATED;
v8::Handle<v8::Value> prelude_result = run_script(get_context());
if (!exit_cancellable_region())
return S_TERMINATED;
if (prelude_result.IsEmpty())
{
set_last_error("Prelude script did not return any value");
return S_ERROR;
}
if (!prelude_result->IsFunction())
{
set_last_error("Prelude script must return a function");
return S_ERROR;
}
global_template_factory = std::shared_ptr<v8::Persistent<v8::Function>>(
new v8::Persistent<v8::Function>(v8::Isolate::GetCurrent(), prelude_result.As<v8::Function>()));
return S_OK;
}
list_node<_page_cache_file_info>* page_cache_get_finfo(uint32 gfd, uint32 page)
{
if (gfd >= gft_get_table()->count)
{
set_last_error(EBADF, PAGE_CACHE_OUT_OF_BOUNDS, EO_PAGE_CACHE);
return 0;
}
if (gft_get_table()->data[gfd].file_node == 0)
{
set_last_error(EBADF, PAGE_CACHE_INVALID, EO_PAGE_CACHE);
return 0;
}
auto temp = gft_get_table()->data[gfd].pages.head;
while (temp != 0)
{
if (temp->data.page == page)
return temp;
temp = temp->next;
}
set_last_error(EINVAL, PAGE_CACHE_FINFO_NOT_FOUND, EO_PAGE_CACHE);
return 0;
}
int
varnam_config(varnam *handle, int type, ...)
{
va_list args;
int rc = VARNAM_SUCCESS;
if (handle == NULL)
return VARNAM_ARGS_ERROR;
set_last_error (handle, NULL);
va_start (args, type);
switch (type)
{
case VARNAM_CONFIG_USE_DEAD_CONSONANTS:
handle->internal->config_use_dead_consonants = va_arg(args, int);
break;
case VARNAM_CONFIG_IGNORE_DUPLICATE_TOKEN:
handle->internal->config_ignore_duplicate_tokens = va_arg(args, int);
break;
default:
set_last_error (handle, "Invalid configuration key");
rc = VARNAM_INVALID_CONFIG;
}
va_end (args);
return rc;
}
ptz_t *ptz2_open(const char *name, int addr)
{
SERIALS::iterator it = _serials2.find(name);
if (it == _serials2.end()) {
int err;
visca_serial_t *vs = visca_open_serial(name, &err);
if (!vs) {
set_last_error(-1);
fprintf(stderr, "[ptz][%s]: %s: open %s fault!\n", name, __FUNCTION__, name);
return 0;
}
int m;
if (visca_set_address(vs, &m) < 0) {
fprintf(stderr, "[ptz][%s]: %s: can't get cam nums\n", name, __FUNCTION__);
set_last_error(-2);
return 0;
}
fprintf(stderr, "[ptz][%s]: %s There are %d cams\n", name, __FUNCTION__, m);
Serial *s = new Serial;
s->vs = vs;
_serials2[name] = s;
/// prepare addrs
for (int i = 0; i <= m; i++) {
Ptz *p = new Ptz;
if (i == 0) {
p->addr = 1; // 当外部传递 addr=0 时，使用 1
}
else {
p->addr = addr;
}
p->serial = s;
p->serial_name = name;
p->cfg = 0;
p->zvc = 0;
s->cams.push_back(p);
}
return ptz2_open(name, addr);
}
else {
Serial *s = it->second;
if (addr >= s->cams.size()) {
fprintf(stderr, "[ptz][%s]: %s: invalid addr, using 1..%d\n", visca_name(s->vs), __FUNCTION__, s->cams.size()-1);
set_last_error(-4);
return 0;
}
else {
set_last_error(0);
s->ref++;
return (ptz_t*)s->cams[addr];
}
}
}
/**
* @brief Run all of the requirements in a reqlist
* @param fctx the context to use (argc and argv will be updated in it)
* @param reqlist the list
* @param req the function to execute (currently only req_requirement_met)
* @return 0 if ok
*/
int req_apply_reqlist(struct fun_context *fctx, cfg_opt_t *reqlist, int (*req)(struct fun_context *fctx))
{
int ix = 0;
char *aritystr;
while ((aritystr = cfg_opt_getnstr(reqlist, ix++)) != NULL) {
fctx->argc = strtoul(aritystr, NULL, 0);
if (fctx->argc <= 0 || fctx->argc > FUN_MAX_ARGS) {
set_last_error("Unexpected argc value in reqlist");
return -1;
}
int i;
for (i = 0; i < fctx->argc; i++) {
fctx->argv[i] = cfg_opt_getnstr(reqlist, ix++);
if (fctx->argv[i] == NULL) {
set_last_error("Unexpected error with reqlist");
return -1;
}
}
// Clear out the rest of the argv entries to avoid confusion when debugging.
for (; i < FUN_MAX_ARGS; i++)
fctx->argv[i] = 0;
if (req(fctx) < 0)
return -1;
}
return 0;
}
void* heap_realloc(heap* h, void* address, uint32 new_size)
{
if (h == 0 || address == 0)
{
set_last_error(EINVAL, HEAP_BAD_ARGUMENT, EO_HMMNGR);
return 0;
}
heap_block* block = (heap_block*)((char*)address - sizeof(heap_block));
if (block->magic != HEAP_BLOCK_MAGIC)
{
set_last_error(EINVAL, HEAP_BAD_MAGIC, EO_HMMNGR);
return 0;
}
uint32 block_size = heap_block_size(h, block);
if (block_size == new_size)
return address;
/*if (new_size < block_size) // request to shrink allocated space
{
// try squeeze a new block
if (heap_is_next_unused(block)) // only one front merge required to squeeze a block
heap_front_merge_block(h, block);
uint32 remaining_size = heap_block_size(h, block) - new_size; // be careful as block size may have changed
if (remaining_size > sizeof(heap_block)) // squeeze a new block
{
heap_block* new_block = heap_block_create(h, (char*)address + new_size, false, block->next, block->flags);
block->next = new_block;
}
return heap_block_start_address(block);
}
else if (new_size > block_size)
{
if (heap_front_merge_size_fit(h, block, new_size))
{
}
}
else
return address; // re-allocation does nothing as 'new_size' equals the currently allocated 'block_size'*/
#ifndef HEAP_REALLOC_FIRST_IMPLEMENT
//uint32 block_size = heap_block_size(h, block);
void* new_addr = heap_alloc(h, new_size);
if (new_addr == 0)
return 0;
memcpy(new_addr, address, min(block_size, new_size));
if (heap_free(h, address) != ERROR_OK)
return 0;
return new_addr;
#endif
}
int save_config_file(char_t const* config_path)
{
int i = 0;
int size = 0;
HANDLE file_handle = NULL;
char tmp_buf[MAX_STRING_SIZE] = {0};
file_handle = CreateFile(config_path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(file_handle == INVALID_HANDLE_VALUE){
set_last_error(IDS_STRING5008);
output_log(IDS_STRING5008, get_last_error());
return APP_FAULT;
}
for(i = 0; i < __config_file_line_size; ++i){
strcpy(tmp_buf, __config_file_lines[i].line_);
size = strlen(tmp_buf);
tmp_buf[size++] = 0xd;
tmp_buf[size++] = 0xa;
tmp_buf[size] = NULL;
if(!WriteFile(file_handle, tmp_buf, size, (DWORD*)&size, NULL)){
set_last_error(IDS_STRING5011);
output_log(IDS_STRING5011, get_last_error());
}
}
if(file_handle != INVALID_HANDLE_VALUE) CloseHandle(file_handle);
return APP_SUCCESS;
}
/**
* @brief Validate a TFTF header
*
* @param header The TFTF header to validate
*
* @returns True if valid TFTF header, false otherwise
*/
bool valid_tftf_header(tftf_header * header) {
tftf_section_descriptor * section;
bool section_contains_start = false;
bool end_of_sections = false;
uint8_t * end_of_header;
int i;
/* Verify the sentinel */
for (i = 0; i < TFTF_SENTINEL_SIZE; i++) {
if (header->sentinel_value[i] != tftf_sentinel[i]) {
set_last_error(BRE_TFTF_SENTINEL);
return false;
}
}
if ((header->header_size < TFTF_HEADER_SIZE_MIN) ||
(header->header_size > TFTF_HEADER_SIZE_MAX)) {
set_last_error(BRE_TFTF_HEADER_SIZE);
return false;
}
/* Verify all of the sections */
for (section = &header->sections[0];
(section < &header->sections[tftf_max_sections]) && !end_of_sections;
section++) {
if (!valid_tftf_section(section, header, §ion_contains_start,
&end_of_sections)) {
/* (valid_tftf_section took care of error reporting) */
return false;
}
}
if (!end_of_sections) {
set_last_error(BRE_TFTF_NO_TABLE_END);
return false;
}
/* Verify that, if this TFTF has a start address, it falls in one of our code sections. */
if ((header->start_location != 0) && !section_contains_start) {
set_last_error(BRE_TFTF_START_NOT_IN_CODE);
return false;
}
/*
* Verify that the remainder of the header (i.e., unused section
* descriptors and the padding) is zero-filled
*/
end_of_header = (uint8_t *)(header);
end_of_header += header->header_size;
if (!is_constant_fill((uint8_t *)section,
end_of_header - (uint8_t *)section,
0x00)) {
set_last_error(BRE_TFTF_NON_ZERO_PAD);
return false;
}
return true;
}
BOOL netconn_secure_connect( netconn_t *conn )
{
#ifdef SONAME_LIBSSL
X509 *cert;
long res;
ctx = pSSL_CTX_new( method );
if (!pSSL_CTX_set_default_verify_paths( ctx ))
{
ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_OUTOFMEMORY );
return FALSE;
}
if (!(conn->ssl_conn = pSSL_new( ctx )))
{
ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_OUTOFMEMORY );
goto fail;
}
if (!pSSL_set_fd( conn->ssl_conn, conn->socket ))
{
ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
goto fail;
}
if (pSSL_connect( conn->ssl_conn ) <= 0)
{
ERR("SSL_connect failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
goto fail;
}
if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn )))
{
ERR("No certificate for server: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
goto fail;
}
if ((res = pSSL_get_verify_result( conn->ssl_conn )) != X509_V_OK)
{
/* FIXME: we should set an error and return, but we only print an error at the moment */
ERR("couldn't verify server certificate (%ld)\n", res);
}
TRACE("established SSL connection\n");
conn->secure = TRUE;
return TRUE;
fail:
if (conn->ssl_conn)
{
pSSL_shutdown( conn->ssl_conn );
pSSL_free( conn->ssl_conn );
conn->ssl_conn = NULL;
}
#endif
return FALSE;
}
static bool
can_learn_from_tokens (varnam *handle, varray *tokens, const char *word)
{
bool all_vowels = true, unknown_tokens = false;
int i, j, repeating_tokens = 0, last_token_id = 0;
vtoken *t, *unknown_token;
varray *array;
if (varray_length (tokens) < 2) {
set_last_error (handle, "Nothing to learn from '%s'", word);
return false;
}
for (i = 0; i < varray_length (tokens); i++)
{
array = varray_get (tokens, i);
for (j = 0; j < varray_length (array); j++)
{
t = varray_get (array, j);
if (t->type != VARNAM_TOKEN_VOWEL) all_vowels = false;
if (t->type == VARNAM_TOKEN_OTHER) {
unknown_tokens = true;
unknown_token = t;
goto done;
}
if (last_token_id == t->id) {
++repeating_tokens;
}
else {
repeating_tokens = 0;
last_token_id = t->id;
}
}
}
done:
if (all_vowels) {
set_last_error (handle, "Word contains only vowels. Nothing to learn from '%s'", word);
return false;
}
else if (unknown_tokens) {
set_last_error (handle, "Can't process '%s'. One or more characters in '%s' are not known", unknown_token->pattern, word);
return false;
}
else if (repeating_tokens >= 3) {
set_last_error (handle, "'%s' looks incorrect. Not learning anything", word);
return false;
}
return true;
}
_variant_t RecordSet::get_field_value(const std::basic_string<TCHAR>& name) {
_variant_t value;
try {
set_last_error(S_OK);
value = record_set_ptr_->GetCollect(name.c_str());
} catch (_com_error& e) {
set_last_error(e);
}
return _variant_t(value);
}
bool RecordSet::get_field_value(const std::basic_string<TCHAR>& name, _variant_t& value) {
try {
set_last_error(S_OK);
value = record_set_ptr_->GetCollect(name.c_str());
} catch (_com_error& e) {
set_last_error(e);
return false;
}
return true;
}
bool RecordSet::is_empty() {
ADO_LONGPTR count = 0;
try {
set_last_error(S_OK);
count = record_set_ptr_->GetRecordCount();
} catch(_com_error& e) {
set_last_error(e);
}
return count == 0;
}
long RecordSet::get_field_count() {
try {
set_last_error(S_OK);
FieldsPtr fields_ptr = record_set_ptr_->GetFields();
if (fields_ptr != nullptr)
return fields_ptr->GetCount();
} catch (_com_error& e) {
set_last_error(e);
}
return 0;
}
bool RecordSet::get_param_value(const std::basic_string<TCHAR>& param_name, _variant_t& value) {
try {
set_last_error(S_OK);
value = command_ptr_->Parameters->GetItem(_variant_t(_bstr_t(param_name.c_str())))->Value;
} catch (_com_error& e) {
set_last_error(e);
return false;
}
return true;
}
// TODO: APPLY NEW FIX
error_t page_cache_release_buffer(uint32 gfd, uint32 page)
{
//if (gfd >= page_cache.cached_files.count || page_cache.cached_files[gfd].gfd == INVALID_FD) // kinda erroneous gfd
//{
// set_last_error(EBADF, PAGE_CACHE_INVALID, EO_PAGE_CACHE);
// return ERROR_OCCUR;
//}
uint32 index = -1;
// remove index from page list
auto list = &gft_get_table()->data[gfd].pages;
auto prev = list->head;
if (prev == 0)
{
DEBUG("Page cache release got zero length page list");
set_last_error(EINVAL, PAGE_CACHE_BAD_PAGES, EO_PAGE_CACHE);
return ERROR_OCCUR;
}
if (prev->data.page == page)
{
index = prev->data.buffer_index;
list_remove_front(list); // TODO: Check this line for errors
}
else
{
while (prev->next != 0)
{
if (prev->next->data.page == page)
{
index = prev->next->data.buffer_index;
list_remove(list, prev); // TODO: Check this line for errors
break;
}
prev = prev->next;
}
}
if (index == -1)
{
DEBUG("Page not found to release");
set_last_error(EINVAL, PAGE_CACHE_PAGE_NOT_FOUND, EO_PAGE_CACHE);
return ERROR_OCCUR;
}
page_cache_release_anonymous(page_cache_addr_by_index(index));
return ERROR_OK;
}
BOOL netconn_secure_connect( netconn_t *conn, WCHAR *hostname )
{
#ifdef SONAME_LIBSSL
if (!(conn->ssl_conn = pSSL_new( ctx )))
{
ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_OUTOFMEMORY );
goto fail;
}
if (!pSSL_set_ex_data( conn->ssl_conn, hostname_idx, hostname ))
{
ERR("SSL_set_ex_data failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
goto fail;
}
if (!pSSL_set_ex_data( conn->ssl_conn, conn_idx, conn ))
{
ERR("SSL_set_ex_data failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
return FALSE;
}
if (!pSSL_set_fd( conn->ssl_conn, conn->socket ))
{
ERR("SSL_set_fd failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
goto fail;
}
if (pSSL_connect( conn->ssl_conn ) <= 0)
{
DWORD err;
err = (DWORD_PTR)pSSL_get_ex_data( conn->ssl_conn, error_idx );
if (!err) err = ERROR_WINHTTP_SECURE_CHANNEL_ERROR;
ERR("couldn't verify server certificate (%d)\n", err);
set_last_error( err );
goto fail;
}
TRACE("established SSL connection\n");
conn->secure = TRUE;
return TRUE;
fail:
if (conn->ssl_conn)
{
pSSL_shutdown( conn->ssl_conn );
pSSL_free( conn->ssl_conn );
conn->ssl_conn = NULL;
}
#endif
return FALSE;
}
BOOL netconn_close( netconn_t *conn )
{
int res;
if (conn->secure)
{
heap_free( conn->peek_msg_mem );
conn->peek_msg_mem = NULL;
conn->peek_msg = NULL;
conn->peek_len = 0;
heap_free(conn->ssl_buf);
conn->ssl_buf = NULL;
heap_free(conn->extra_buf);
conn->extra_buf = NULL;
conn->extra_len = 0;
DeleteSecurityContext(&conn->ssl_ctx);
conn->secure = FALSE;
}
res = closesocket( conn->socket );
conn->socket = -1;
if (res == -1)
{
set_last_error( sock_get_error( errno ) );
return FALSE;
}
return TRUE;
}
BOOL netconn_close( netconn_t *conn )
{
int res;
#ifdef SONAME_LIBSSL
if (conn->secure)
{
heap_free( conn->peek_msg_mem );
conn->peek_msg_mem = NULL;
conn->peek_msg = NULL;
conn->peek_len = 0;
pSSL_shutdown( conn->ssl_conn );
pSSL_free( conn->ssl_conn );
conn->ssl_conn = NULL;
conn->secure = FALSE;
}
#endif
res = closesocket( conn->socket );
conn->socket = -1;
if (res == -1)
{
set_last_error( sock_get_error( errno ) );
return FALSE;
}
return TRUE;
}
uint32 lft_insert(local_file_table* lft, lfe entry)
{
if (entry.gfd >= gft.count)
{
set_last_error(EBADF, OPEN_FILE_BAD_GLOBAL_DESCRIPTOR, EO_OPEN_FILE_TBL);
return INVALID_FD;
}
spinlock_acquire(&lft->lock);
uint32 loc_index;
// if there is space past the last entry or there are no unused entries => push backa new one
if ((lft->entries.count < lft->entries.r_size) || (loc_index = vector_find_first(&lft->entries, lfe_is_invalid)) >= lft->entries.r_size)
{
if (vector_insert_back(&lft->entries, entry) != ERROR_OK)
{
spinlock_release(&lft->lock);
return INVALID_FD;
}
loc_index = lft->entries.count - 1;
}
// else consume the existing entry found above
lft->entries[loc_index] = entry;
spinlock_release(&lft->lock);
return loc_index;
}
BOOL netconn_resolve( WCHAR *hostname, INTERNET_PORT port, struct sockaddr *sa, socklen_t *sa_len, int timeout )
{
DWORD ret;
if (timeout)
{
DWORD status;
HANDLE thread;
struct resolve_args ra;
ra.hostname = hostname;
ra.port = port;
ra.sa = sa;
ra.sa_len = sa_len;
thread = CreateThread( NULL, 0, resolve_proc, &ra, 0, NULL );
if (!thread) return FALSE;
status = WaitForSingleObject( thread, timeout );
if (status == WAIT_OBJECT_0) GetExitCodeThread( thread, &ret );
else ret = ERROR_WINHTTP_TIMEOUT;
CloseHandle( thread );
}
else ret = resolve_hostname( hostname, port, sa, sa_len );
if (ret)
{
set_last_error( ret );
return FALSE;
}
return TRUE;
}
ptz_t *ptz_open(const char *name, int addr)
{
fprintf(stderr, "DEBUG: %s: try to open serial name: %s, addr=%d\n", __FUNCTION__, name, addr);
if (!name) {
set_last_error(ERR_INVALID_PARAMS);
return 0;
}
if (addr > 7 || addr < 0) {
set_last_error(ERR_INVALID_PARAMS);
return 0;
}
return ptz2_open(name, addr);
}
BOOL netconn_send( netconn_t *conn, const void *msg, size_t len, int *sent )
{
if (!netconn_connected( conn )) return FALSE;
if (conn->secure)
{
const BYTE *ptr = msg;
size_t chunk_size;
*sent = 0;
while(len) {
chunk_size = min(len, conn->ssl_sizes.cbMaximumMessage);
if(!send_ssl_chunk(conn, ptr, chunk_size))
return FALSE;
*sent += chunk_size;
ptr += chunk_size;
len -= chunk_size;
}
return TRUE;
}
if ((*sent = sock_send( conn->socket, msg, len, 0 )) == -1)
{
set_last_error( sock_get_error( errno ) );
return FALSE;
}
return TRUE;
}
static int start_write2(lcb_io_opt_t iobase,
lcb_sockdata_t *sockbase,
struct lcb_iovec_st *iov,
lcb_size_t niov,
void *uarg,
lcb_ioC_write2_callback callback)
{
my_write_t *w;
my_sockdata_t *sd = (my_sockdata_t *)sockbase;
int ret;
w = calloc(1, sizeof(*w));
w->w.data = uarg;
w->callback = callback;
w->sock = sd;
ret = uv_write(&w->w, (uv_stream_t *)&sd->tcp,
(uv_buf_t *)iov,
niov,
write2_callback);
if (ret != 0) {
free(w);
set_last_error((my_iops_t *)iobase, -1);
}
return ret;
}
/******************************************************************************
******************************************************************************
** Socket Functions **
******************************************************************************
******************************************************************************/
static lcb_sockdata_t *create_socket(lcb_io_opt_t iobase,
int domain,
int type,
int protocol)
{
my_sockdata_t *ret;
my_iops_t *io = (my_iops_t *)iobase;
ret = calloc(1, sizeof(*ret));
if (!ret) {
return NULL;
}
uv_tcp_init(io->loop, &ret->tcp.t);
incref_iops(io);
incref_sock(ret);
set_last_error(io, 0);
(void)domain;
(void)type;
(void)protocol;
return (lcb_sockdata_t *)ret;
}
int assign_unicode_string(void* value_ptr, const char* value_string)
{
int i_ret = APP_SUCCESS;
char tmp_value[MAX_STRING_SIZE] = {0};
char* ch_ptr = tmp_value;
size_t size = 0;
wchar_t wc_tmp_value[MAX_STRING_SIZE] = {0};
strcpy_s(tmp_value, MAX_STRING_SIZE - 1, value_string);
while(*ch_ptr)
if(*ch_ptr == '\"') *ch_ptr++ = ' ';
else ++ch_ptr;
StrTrimA(tmp_value, " ");
mbstowcs_s(&size, NULL, 0, tmp_value, 0);
mbstowcs_s(&size, wc_tmp_value, size, tmp_value, size);
wc_tmp_value[size] = 0x0;
if(size == (size_t) -1){
set_last_error(IDS_STRING5012);
output_log(IDS_STRING5012);
return i_ret = APP_FAULT;
}
StrCpy((wchar_t*)value_ptr, wc_tmp_value);
return i_ret;
}
void
guestfs_perrorf (guestfs_h *g, const char *fs, ...)
{
va_list args;
char *msg;
int errnum = errno;
va_start (args, fs);
int err = vasprintf (&msg, fs, args);
va_end (args);
if (err < 0) return;
char buf[256];
strerror_r (errnum, buf, sizeof buf);
msg = safe_realloc (g, msg, strlen (msg) + 2 + strlen (buf) + 1);
strcat (msg, ": ");
strcat (msg, buf);
/* set_last_error first so that the callback can access the error
* message and errno through the handle if it wishes.
*/
set_last_error (g, errnum, msg);
if (g->error_cb) g->error_cb (g, g->error_cb_data, msg);
free (msg);
}
void rxtx_task_exec_stop(struct rxtx_data *rxtx, unsigned char *requests,
struct bladerf *dev)
{
int status;
*requests = rxtx_get_requests(rxtx,
RXTX_TASK_REQ_STOP | RXTX_TASK_REQ_SHUTDOWN);
pthread_mutex_lock(&rxtx->data_mgmt.lock);
bladerf_deinit_stream(rxtx->data_mgmt.stream);
rxtx->data_mgmt.stream = NULL;
pthread_mutex_unlock(&rxtx->data_mgmt.lock);
pthread_mutex_lock(&rxtx->file_mgmt.file_lock);
if (rxtx->file_mgmt.file != NULL) {
fclose(rxtx->file_mgmt.file);
rxtx->file_mgmt.file = NULL;
}
pthread_mutex_unlock(&rxtx->file_mgmt.file_lock);
if (*requests & RXTX_TASK_REQ_SHUTDOWN) {
rxtx_set_state(rxtx, RXTX_STATE_SHUTDOWN);
} else {
rxtx_set_state(rxtx, RXTX_STATE_IDLE);
}
status = bladerf_enable_module(dev, rxtx->module, false);
if (status < 0) {
set_last_error(&rxtx->last_error, ETYPE_BLADERF, status);
}
*requests = 0;
rxtx_release_wait(rxtx);
}
