C++ set_last_error函数代码示例

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, &section_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;
}

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);
}

// 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;
}