static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
CHECK_HANDLE(handle);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
static int set_offset(int handle, off_t newoffset ){
CHECK_HANDLE(handle);
off_t oldoffset = s_handle_slots[handle].offset;
ZRT_LOG_PARAM(L_INFO, P_INT, handle);
ZRT_LOG_PARAM(L_INFO, P_LONGINT, oldoffset);
ZRT_LOG_PARAM(L_INFO, P_LONGINT, newoffset);
s_handle_slots[handle].offset = newoffset;
return 0;
}
static void sv_send_cb(uv_udp_send_t* req, int status) {
ASSERT(req != NULL);
ASSERT(status == 0);
CHECK_HANDLE(req->handle);
sv_send_cb_called++;
uv_close((uv_handle_t*) req->handle, close_cb);
}
int scytale_reader_open(RedCryptoReaderHandle * handle, char const * path, char const * derivator) {
SCOPED_TRACE;
CHECK_HANDLE(handle);
handle->error_ctx.set_error(Error(NO_ERROR));
CHECK_NOTHROW(
handle->in_crypto_transport.open(path, {derivator, strlen(derivator)}),
ERR_TRANSPORT_OPEN_FAILED);
return 0;
}
int pcmcia_access_configuration_register(client_handle_t handle,
conf_reg_t *reg)
{
struct pcmcia_socket *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
return pccard_access_configuration_register(s, handle->Function, reg);
}
static void send_cb(uv_udp_send_t* req, int status) {
CHECK_REQ(req);
CHECK_HANDLE(req->handle);
ASSERT(status == UV_EMSGSIZE);
uv_close((uv_handle_t*)req->handle, close_cb);
send_cb_called++;
}
void DDSChatModule::startupPublisher(void)
{
// Create publisher and set user data as "<name>,<id>"
pPub = pDomainParticipant->create_publisher(DDS_PUBLISHER_QOS_DEFAULT,NULL,
DDS_STATUS_MASK_NONE);
CHECK_HANDLE(pPub,"Cannot create publisher\n");
printf("Created publisher\n");
// Create data writers for respective topics
for(int iTopic=0; iTopic<(MAX_TOPICS-1); iTopic++)
{
pWriter[iTopic] = pPub->create_datawriter(pTopic[iTopic],DDS_DATAWRITER_QOS_DEFAULT,
NULL,DDS_STATUS_MASK_NONE);
CHECK_HANDLE(pWriter[iTopic],"Cannot create data writer\n");
}
}
int scytale_writer_close(RedCryptoWriterHandle * handle) {
SCOPED_TRACE;
CHECK_HANDLE(handle);
HashArray qhash;
HashArray fhash;
CHECK_NOTHROW(handle->out_crypto_transport.close(qhash, fhash), ERR_TRANSPORT_CLOSED);
hash_to_hashhex(qhash, handle->qhashhex);
hash_to_hashhex(fhash, handle->fhashhex);
return 0;
}
IVS_DRAW_API LONG Draw_GetCursorType(DRAW_HANDLE handle, POINT Point)
{
CHECK_HANDLE(handle);
CIADrawer *pIADrawer = (CIADrawer *)handle;
if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&Point))
{
return CURSOR_TYPE_ARROW;
}
return pIADrawer->GetCursorType(Point);
}
// 根据鼠标点坐标选中智能分析单个图形（选择特定组中与鼠标坐标最近的单个图形）
IVS_DRAW_API LONG Draw_SelectGraphicByGraphicPoint(DRAW_HANDLE handle, POINT point, ULONG *ulGraphicGroup, BOOL *bAllowDel)
{
CHECK_HANDLE(handle);
if ((NULL == ulGraphicGroup) || (NULL == bAllowDel))
{
return IVS_PARA_INVALID;
}
CIADrawer *pIADrawer = (CIADrawer *)handle;
return pIADrawer->SelectGraphicByPoint(point, *ulGraphicGroup, *bAllowDel);
}
int scytale_meta_reader_read_hash(RedCryptoMetaReaderHandle * handle, int version, int has_checksum)
{
SCOPED_TRACE;
CHECK_HANDLE(handle);
handle->mwrm_reader.set_header({static_cast<WrmVersion>(version), bool(has_checksum)});
CHECK_NOTHROW(
handle->mwrm_reader.read_meta_hash_line(handle->meta_line),
ERR_TRANSPORT_READ_FAILED);
return 0;
}
int scytale_meta_reader_read_line(RedCryptoMetaReaderHandle * handle)
{
SCOPED_TRACE;
CHECK_HANDLE(handle);
CHECK_NOTHROW(
handle->eof
= Transport::Read::Eof == handle->mwrm_reader.read_meta_line(handle->meta_line),
ERR_TRANSPORT_READ_FAILED);
return handle->eof ? ERR_TRANSPORT_NO_MORE_DATA : 0;
}
int scytale_reader_qhash(RedCryptoReaderHandle * handle, const char * file)
{
SCOPED_TRACE;
CHECK_HANDLE(handle);
CHECK_NOTHROW(
InCryptoTransport::HASH qhash = handle->in_crypto_transport.qhash(file);
hash_to_hashhex(qhash.hash, handle->qhashhex),
ERR_TRANSPORT_READ_FAILED
);
return 0;
}
// 智能分析点击确定U型框中间节点位置坐标
IVS_DRAW_API LONG Draw_ULineSetPoint(DRAW_HANDLE handle, POINT point, ULONG /*ulGraphicGroup*/)
{
CHECK_HANDLE(handle);
CIADrawer *pIADrawer = (CIADrawer *)handle;
if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))
{
// pIADrawer->StopDrawGraphics(ulGraphicGroup);
return IVS_FAIL;
}
return pIADrawer->DrawIAULine(point, TRUE, FALSE, TRUE);
}
// 选中指定图形组的所有图形
IVS_DRAW_API LONG Draw_SelectGraphicByGroup(DRAW_HANDLE handle, ULONG ulGraphicGroup, BOOL *bAllowDel)
{
CHECK_HANDLE(handle);
if (NULL == bAllowDel)
{
return IVS_PARA_INVALID;
}
CIADrawer *pIADrawer = (CIADrawer *)handle;
return pIADrawer->SelectGraphicByGroup(ulGraphicGroup, *bAllowDel);
}
static void ipv6_recv_ok(uv_udp_t* handle,
ssize_t nread,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(nread >= 0);
if (nread)
recv_cb_called++;
}
// 智能分析结束修改图形
IVS_DRAW_API LONG Draw_ModifyFinish(DRAW_HANDLE handle, ULONG ulGraphicGroup, POINT point)
{
CHECK_HANDLE(handle);
CIADrawer *pIADrawer = (CIADrawer *)handle;
if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))
{
pIADrawer->InsertCurrentToGraphicList();
return IVS_SUCCEED;
}
return pIADrawer->ModifyIAShapeUpDate(point, TRUE, ulGraphicGroup);
}
void fcrystal_ituple_transfer(const sint *handle,
sint A[], const sint *m, sint *n,
const sint *nmax, const sint *proc_key)
{
struct array ar, *const ar_ptr = &ar;
const unsigned size=(*m)*sizeof(sint);
CHECK_HANDLE("crystal_ituple_transfer");
ar.ptr=A, ar.n=*n, ar.max=*nmax;
*n = sarray_transfer_many(&ar_ptr,&size,1, 1,0,1,(*proc_key-1)*sizeof(sint),
(uint*)&A[*proc_key-1],size, handle_array[*handle]);
}
void create_simple(pointless_create_t* c)
{
// error string
const char* error = 0;
// vector
uint32_t vector_handle = pointless_create_vector_value(c);
CHECK_HANDLE(vector_handle);
// bitvector
uint32_t value = 123;
uint32_t bitvector_handle = pointless_create_bitvector(c, &value, 27);
CHECK_HANDLE(bitvector_handle);
// string
uint32_t string_handle = pointless_create_string_ascii(c, (uint8_t*)"Arni Mar Jonsson");
if (string_handle == POINTLESS_CREATE_VALUE_FAIL) {
fprintf(stderr, "pointless_create_string_ascii() failure\n");
exit(EXIT_FAILURE);
}
uint32_t unicode_handle = pointless_create_unicode_ascii(c, "Arni Mar Jonsson", &error);
if (string_handle == POINTLESS_CREATE_VALUE_FAIL) {
fprintf(stderr, "pointless_create_unicode_ascii() failure: %s\n", error);
exit(EXIT_FAILURE);
}
// add to vector
uint32_t i, handles[] = { bitvector_handle, vector_handle, string_handle, unicode_handle };
for (i = 0; i < 4; i++) {
if (pointless_create_vector_value_append(c, vector_handle, handles[i]) == POINTLESS_CREATE_VALUE_FAIL) {
fprintf(stderr, "pointless_create_vector_append() failure\n");
exit(EXIT_FAILURE);
}
}
pointless_create_set_root(c, vector_handle);
}
static geBoolean GENESISCC FSDos_SetHints(void *Handle, const geVFile_Hints *Hints)
{
DosFile * File;
File = Handle;
CHECK_HANDLE(File);
assert(File->FileHandle != INVALID_HANDLE_VALUE);
return GE_FALSE;
}
static void cl_send_cb(uv_udp_send_t* req, int status) {
int r;
ASSERT(req != NULL);
ASSERT(status == 0);
CHECK_HANDLE(req->handle);
r = uv_udp_recv_start(req->handle, alloc_cb, cl_recv_cb);
ASSERT(r == 0);
cl_send_cb_called++;
}
int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
{
struct pcmcia_socket *skt;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
skt = SOCKET(handle);
if (!skt)
return CS_BAD_HANDLE;
return pccard_reset_card(skt);
}
// 智能分析点击确定U型线最后一边并且结束画U型线
// （若已确定三条边，直接结束画图；若第三条边未确定，则以当前点为U型线第三边终点）
IVS_DRAW_API LONG Draw_ULineFinish(DRAW_HANDLE handle, POINT point, ULONG /*ulGraphicGroup*/)
{
CHECK_HANDLE(handle);
CIADrawer *pIADrawer = (CIADrawer *)handle;
if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(&point))
{
pIADrawer->InsertCurrentToGraphicList();
// pIADrawer->StopDrawGraphics(ulGraphicGroup);
return IVS_SUCCEED;
}
return pIADrawer->DrawIAULine(point, TRUE, TRUE, TRUE);
}
int pcmcia_get_configuration_info(client_handle_t handle,
config_info_t *config)
{
struct pcmcia_socket *s;
if ((CHECK_HANDLE(handle)) || !config)
return CS_BAD_HANDLE;
s = SOCKET(handle);
if (!s)
return CS_BAD_HANDLE;
return pccard_get_configuration_info(s, handle->Function, config);
}
IVS_DRAW_API LONG Draw_WindowPointToGraphicPoint(DRAW_HANDLE handle, POINT* pPoint)
{
CHECK_HANDLE(handle);
CIADrawer *pIADrawer = (CIADrawer *)handle;
if (IVS_SUCCEED != pIADrawer->WindowPointToGraphicPoint(pPoint))
{
pIADrawer->InsertCurrentToGraphicList();
// pIADrawer->StopDrawGraphics(ulGraphicGroup);
return IVS_SUCCEED;
}
return IVS_SUCCEED;
}
/*++
Routine Name:
CUICtrlFeatNUpCombo::EnableDependentCtrls
Routine Description:
This method is used to enable or disable other controls in the UI based on the
current combo box selection.
Arguments:
hDlg - handle to the parent window
lSel - current combo box selection
Return Value:
HRESULT
S_OK - On success
E_* - On error
--*/
HRESULT
CUICtrlFeatNUpCombo::EnableDependentCtrls(
__in CONST HWND hDlg,
__in CONST LONG lSel
)
{
HRESULT hr = S_OK;
HWND hWnd = NULL;
//
// Here we are enabling/disabling the NUp and Binding controls depending on the current
// NUp selection.
//
// When NUp is more than 1 page per sheet we enable the NUp order controls and disable
// binding option controls.
//
if (SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_NUP_ORDER), E_HANDLE)))
{
EnableWindow(hWnd, lSel > NUP_1PPS_SEL);
}
if (SUCCEEDED(hr) &&
SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_NUP_ORDER), E_HANDLE)))
{
EnableWindow(hWnd, lSel > NUP_1PPS_SEL);
}
if (SUCCEEDED(hr) &&
SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_JOBBIND), E_HANDLE)))
{
EnableWindow(hWnd, lSel == NUP_1PPS_SEL);
}
if (SUCCEEDED(hr) &&
SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_JOBBIND), E_HANDLE)))
{
EnableWindow(hWnd, lSel == NUP_1PPS_SEL);
}
if (SUCCEEDED(hr) &&
SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_COMBO_DOCBIND), E_HANDLE)))
{
EnableWindow(hWnd, lSel == NUP_1PPS_SEL);
}
if (SUCCEEDED(hr) &&
SUCCEEDED(hr = CHECK_HANDLE(hWnd = GetDlgItem(hDlg, IDC_TXT_DOCBIND), E_HANDLE)))
{
EnableWindow(hWnd, lSel == NUP_1PPS_SEL);
}
if (FAILED(hr))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
ERR_ON_HR(hr);
return hr;
}
kadm5_ret_t kadm5_chpass_principal_util(void *server_handle,
krb5_principal princ,
char *new_pw,
char **ret_pw,
char *msg_ret,
unsigned int msg_len)
{
kadm5_server_handle_t handle = server_handle;
CHECK_HANDLE(server_handle);
return _kadm5_chpass_principal_util(handle, handle->lhandle, princ,
new_pw, ret_pw, msg_ret, msg_len);
}
static int mtd_set_vpp(client_handle_t handle, mtd_vpp_req_t *req)
{
socket_info_t *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
if (req->Vpp1 != req->Vpp2)
return CS_BAD_VPP;
s = SOCKET(handle);
s->socket.Vpp = req->Vpp1;
if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))
return CS_BAD_VPP;
return CS_SUCCESS;
}
static int mtd_rdy_mask(client_handle_t handle, mtd_rdy_req_t *req)
{
socket_info_t *s;
if (CHECK_HANDLE(handle))
return CS_BAD_HANDLE;
s = SOCKET(handle);
if (req->Mask & CS_EVENT_READY_CHANGE)
s->socket.csc_mask |= SS_READY;
else
s->socket.csc_mask &= ~SS_READY;
if (s->ss_entry(s->sock, SS_SetSocket, &s->socket))
return CS_GENERAL_FAILURE;
return CS_SUCCESS;
}
void
POMP2_Parallel_fork( POMP2_Region_handle* pomp2_handle,
int if_clause,
int num_threads,
POMP2_Task_handle* pomp2_old_task,
const char ctc_string[] )
{
EPIK_Region_descriptor* rdescr = (EPIK_Region_descriptor*) (*pomp2_handle);
CHECK_HANDLE();
*pomp2_old_task = pomp2_current_task;
if( pomp2_tracing )
{
esd_omp_fork( rdescr->rid );
}
}
