int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters) {
assert(encoding != NULL);
if (num_bytes == 0) {
*characters = xnew(jschar, 0);
*num_characters = 0;
return 0;
}
UINT code_page;
if (find_code_page(encoding, &code_page) != 0) {
return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
}
if (num_bytes > INT_MAX) {
fatal("overflow");
}
*characters = xnew(jschar, num_bytes);
int result = MultiByteToWideChar(code_page, MB_ERR_INVALID_CHARS, bytes, num_bytes, *characters, num_bytes);
if (result == 0) {
free(*characters);
return JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE;
}
*num_characters = result;
skip_bom(characters, num_characters);
return 0;
}
KDCENTRY* krb_locate_kdc(rdpSettings* settings)
{
#ifdef WITH_RESOLV
char *qname;
int reslen, i;
unsigned char response[4096];
char kdc_host[4096];
unsigned char* temp;
KDCENTRY* head;
KDCENTRY* kdcentry;
KDCENTRY* srvans;
ns_msg handle;
ns_rr rr;
head = kdcentry = NULL;
if (get_krb_realm(settings))
return NULL;
if (settings->kerberos_kdc)
{
srvans = xnew(KDCENTRY);
srvans->kdchost = xstrdup(settings->kerberos_kdc);
srvans->port = 88;
return srvans;
}
qname = get_dns_queryname(settings->kerberos_realm, "_tcp.");
if ((reslen = res_query(qname, ns_c_in, ns_t_srv, response, sizeof(response))) < 0)
return NULL;
ns_initparse(response, reslen, &handle);
for (i = 0;i < ns_msg_count(handle, ns_s_an);i++)
{
ns_parserr(&handle, ns_s_an, i, &rr);
srvans = xnew(KDCENTRY);
temp = (unsigned char*)ns_rr_rdata(rr);
GETUINT16(temp, &(srvans->priority));
GETUINT16(temp, &(srvans->weight));
GETUINT16(temp, &(srvans->port));
if (ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle), temp, (char*)kdc_host, sizeof(kdc_host)) < 0)
srvans->kdchost = xstrdup((const char*)temp);
else
srvans->kdchost = xstrdup(kdc_host);
if (head == NULL || head->priority > srvans->priority)
{
srvans->next = head;
head = srvans;
}
else
{
for (kdcentry = head;kdcentry->next != NULL && kdcentry->next->priority < srvans->priority;kdcentry = kdcentry->next);
srvans->next = kdcentry->next;
kdcentry->next = srvans;
}
}
return head;
#else
return NULL;
#endif
}
void svc_plugin_init(rdpSvcPlugin* plugin, CHANNEL_ENTRY_POINTS* pEntryPoints)
{
rdpSvcPluginList* list;
/**
* The channel manager will guarantee only one thread can call
* VirtualChannelInit at a time. So this should be safe.
*/
if (g_mutex == NULL)
g_mutex = freerdp_mutex_new();
memcpy(&plugin->channel_entry_points, pEntryPoints, pEntryPoints->cbSize);
plugin->priv = xnew(rdpSvcPluginPrivate);
/* Add it to the global list */
list = xnew(rdpSvcPluginList);
list->plugin = plugin;
freerdp_mutex_lock(g_mutex);
list->next = g_svc_plugin_list;
g_svc_plugin_list = list;
freerdp_mutex_unlock(g_mutex);
plugin->channel_entry_points.pVirtualChannelInit(&plugin->priv->init_handle,
&plugin->channel_def, 1, VIRTUAL_CHANNEL_VERSION_WIN2000, svc_plugin_init_event);
}
static boolean remmina_rdp_pre_connect(freerdp* instance)
{
rfContext* rfi;
rdpSettings* settings;
RemminaProtocolWidget* gp;
rfi = (rfContext*) instance->context;
settings = instance->settings;
gp = rfi->protocol_widget;
settings->bitmap_cache = True;
settings->offscreen_bitmap_cache = True;
settings->order_support[NEG_DSTBLT_INDEX] = True;
settings->order_support[NEG_PATBLT_INDEX] = True;
settings->order_support[NEG_SCRBLT_INDEX] = True;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = True;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = False;
settings->order_support[NEG_MULTIPATBLT_INDEX] = False;
settings->order_support[NEG_MULTISCRBLT_INDEX] = False;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = True;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = False;
settings->order_support[NEG_LINETO_INDEX] = True;
settings->order_support[NEG_POLYLINE_INDEX] = True;
settings->order_support[NEG_MEMBLT_INDEX] = True;
settings->order_support[NEG_MEM3BLT_INDEX] = False;
settings->order_support[NEG_MEMBLT_V2_INDEX] = True;
settings->order_support[NEG_MEM3BLT_V2_INDEX] = False;
settings->order_support[NEG_SAVEBITMAP_INDEX] = False;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_INDEX_INDEX] = True;
settings->order_support[NEG_FAST_GLYPH_INDEX] = False;
settings->order_support[NEG_POLYGON_SC_INDEX] = False;
settings->order_support[NEG_POLYGON_CB_INDEX] = False;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = False;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = False;
if (settings->rfx_codec == True)
{
settings->frame_acknowledge = False;
settings->large_pointer = True;
settings->performance_flags = PERF_FLAG_NONE;
rfi->rfx_context = rfx_context_new();
rfx_context_set_cpu_opt(rfi->rfx_context, CPU_SSE2);
}
freerdp_channels_pre_connect(rfi->channels, instance);
rfi->clrconv = xnew(CLRCONV);
rfi->clrconv->alpha = true;
rfi->clrconv->invert = false;
rfi->clrconv->rgb555 = false;
rfi->clrconv->palette = xnew(rdpPalette);
instance->context->cache = cache_new(instance->settings);
return True;
}
static void output(avp_t *avp, const char *fn)
{
FILE *fp;
int i, j, id, m = 10, nm;
double dvol, *fe, *pr, rho0, rho1, p;
nm = avp->n * m;
xnew(pr, avp->n*m + 1);
xnew(fe, avp->n*m + 1);
/* compute the free energy */
fe[0] = 0;
for (i = 0; i < avp->n; i++) {
p = av_getave( &avp->av[i] );
for (j = 0; j < m; j++) { /* add finer bins */
rho0 = avp->rhomin + (i + 1.0*j/m) * avp->rhodel;
rho1 = avp->rhomin + (i + 1.0*(j+1)/m) * avp->rhodel;
dvol = avp->np/rho1 - avp->np/rho0;
id = i*m + j;
pr[id] = p;
fe[id + 1] = fe[id] - pr[id] * dvol;
}
}
pr[nm] = pr[nm-1];
xfopen(fp, fn, "w", return);
for (i = 0; i <= nm; i++) {
rho0 = avp->rhomin + i * avp->rhodel/m;
fprintf(fp, "%g %g %g\n", rho0, fe[i], pr[i]);
}
fclose(fp);
free(pr);
free(fe);
}
RFX_CONTEXT* rfx_context_new(void)
{
RFX_CONTEXT* context;
context = xnew(RFX_CONTEXT);
context->priv = xnew(RFX_CONTEXT_PRIV);
context->priv->pool = rfx_pool_new();
/* initialize the default pixel format */
rfx_context_set_pixel_format(context, RDP_PIXEL_FORMAT_B8G8R8A8);
/* align buffers to 16 byte boundary (needed for SSE/SSE2 instructions) */
context->priv->y_r_buffer = (sint16*)(((uintptr_t)context->priv->y_r_mem + 16) & ~ 0x0F);
context->priv->cb_g_buffer = (sint16*)(((uintptr_t)context->priv->cb_g_mem + 16) & ~ 0x0F);
context->priv->cr_b_buffer = (sint16*)(((uintptr_t)context->priv->cr_b_mem + 16) & ~ 0x0F);
context->priv->dwt_buffer = (sint16*)(((uintptr_t)context->priv->dwt_mem + 16) & ~ 0x0F);
/* create profilers for default decoding routines */
rfx_profiler_create(context);
/* set up default routines */
context->decode_ycbcr_to_rgb = rfx_decode_ycbcr_to_rgb;
context->encode_rgb_to_ycbcr = rfx_encode_rgb_to_ycbcr;
context->quantization_decode = rfx_quantization_decode;
context->quantization_encode = rfx_quantization_encode;
context->dwt_2d_decode = rfx_dwt_2d_decode;
context->dwt_2d_encode = rfx_dwt_2d_encode;
return context;
}
int main(int argc, char **argv)
{
model_t m[1];
hist_t *hs;
double *beta, *lnz;
int iT;
unsigned flags = 0;
model_default_lj(m);
model_doargs(m, argc, argv);
if ( m->rmcom ) flags |= WHAM_RMCOM;
xnew(beta, m->nT);
xnew(lnz, m->nT);
for ( iT = 0; iT < m->nT; iT++ ) {
beta[iT] = 1./(m->Tmin + m->Tdel * iT);
lnz[iT] = 0;
}
if ( m->loadprev ) {
/* load from existing histogram */
if ( (hs = hist_initf(m->fnhis, HIST_INT | HIST_VERBOSE)) == NULL ) {
return -1;
}
} else {
if ( m->simul == SIMUL_MD ) {
hs = lj_domd(m, beta);
} else {
hs = lj_domc(m, beta);
}
}
whamx(hs, beta, lnz, flags, NULL,
m->damp, m->mdiis_nbases,
m->mdiis_update_method, m->mdiis_threshold,
m->itmin, m->itmax, m->tol, m->verbose,
m->fnlndos, m->fneav, m->wham_method);
if ( m->verbose ) {
double lnzref0 = 0;
for ( iT = 0; iT < hs->rows; iT++ ) {
double tp = 1/beta[iT], tot, eav, var;
double eref, pref, lnzref, muref;
eav = hist_getave(hs, iT, &tot, &var);
eref = ljeos3d_get(m->rho, tp, &pref, &lnzref, &muref);
lnzref *= -m->nn / tp;
if ( iT == 0 ) lnzref0 = lnzref;
printf("%3d %10.7f %14.7f %8.0f %15.7f %14.7f | %10.3f %10.3f\n",
iT, tp, lnz[iT], tot, eav, sqrt(var),
lnzref - lnzref0, eref * m->nn);
}
}
hist_close(hs);
free(beta);
free(lnz);
return 0;
}
/* entropic sampling */
static int run(ising_t *is, double trun)
{
algei_t *al;
double t, *ehis, verr[8], ave2 = 0, alf = 0;
int it = 0, u0 = 0, u1, du = 0;
int *stack, nstack = 0;
xnew(stack, seglen);
al = algei_open(epmin, epmax, epdel, beta0, beta1);
/* equilibrate the system till is->E > epmin */
for (t = 1; is->E <= epmin + 4; t++) {
int id, h;
IS2_PICK(is, id, h);
IS2_FLIP(is, id, h);
}
printf("equilibration finished in %d steps\n", it);
xnew(ehis, ECNT);
u0 = is->E;
for (t = 1; t <= trun; t++) {
ehis[ (is->E - EMIN)/EDEL ] += 1;
move(is, al, stack, &nstack);
if (++it % seglen == 0) {
u1 = is->E;
du = u1 - u0;
assert(u0 >= epmin && u0 < epmax);
algei_fupdate(al, u0, du, alf0, alfc, &alf,
delmax, &ave2, 0, betmax);
if (u1 < epmin || u1 >= epmax) { /* undo out-of-boudary segments */
undo(is, stack, nstack);
u1 = is->E;
}
u0 = u1; /* set the new start point */
nstack = 0; /* clear the stack */
if (it % nevery == 0) {
printf("t %g, ep %d, du %d, e2 %g, alf %g\n", t, is->E, du, ave2, alf);
}
if (it % nreport == 0 || t >= nsteps - .1) {
saveall(al, is->logdos, verr, ehis, fnhis);
printf("trun %g, eabsave %g, eabsmax %g, erelave %g, erelmax %g\n",
trun, verr[0], verr[1], verr[2], verr[3]);
algei_save(al, fnout);
it = 0; /* reset the integer counter */
}
}
}
algei_close(al);
free(ehis);
free(stack);
return 0;
}
RpcVirtualConnection* rpc_client_virtual_connection_new(rdpRpc* rpc)
{
RpcVirtualConnection* virtual_connection = xnew(RpcVirtualConnection);
if (virtual_connection != NULL)
{
virtual_connection->State = VIRTUAL_CONNECTION_STATE_INITIAL;
virtual_connection->DefaultInChannel = xnew(RpcInChannel);
virtual_connection->DefaultOutChannel = xnew(RpcOutChannel);
rpc_client_virtual_connection_init(rpc, virtual_connection);
}
return virtual_connection;
}
int FreeRDPRdpsndDeviceEntry(PFREERDP_RDPSND_DEVICE_ENTRY_POINTS pEntryPoints)
{
rdpsndAudioQPlugin* aqPlugin;
RDP_PLUGIN_DATA* data;
aqPlugin = xnew(rdpsndAudioQPlugin);
aqPlugin->device.Open = rdpsnd_audio_open;
aqPlugin->device.FormatSupported = rdpsnd_audio_format_supported;
aqPlugin->device.SetFormat = rdpsnd_audio_set_format;
aqPlugin->device.SetVolume = rdpsnd_audio_set_volume;
aqPlugin->device.Play = rdpsnd_audio_play;
aqPlugin->device.Start = rdpsnd_audio_start;
aqPlugin->device.Close = rdpsnd_audio_close;
aqPlugin->device.Free = rdpsnd_audio_free;
data = pEntryPoints->plugin_data;
if (data && strcmp((char *)data->data[0], "macaudio") == 0) {
if(strlen((char *)data->data[1]) > 0)
aqPlugin->device_name = strdup((char *)data->data[1]);
else
aqPlugin->device_name = NULL;
}
pEntryPoints->pRegisterRdpsndDevice(pEntryPoints->rdpsnd, (rdpsndDevicePlugin*)aqPlugin);
return 0;
}
rdpBlob* crypto_kdcmsg_decrypt_rc4(rdpBlob* msg, uint8* key, uint32 msgtype)
{
rdpBlob* decmsg;
uint8* K1;
uint8* K3;
uint32 len;
krbEdata* edata;
CryptoRc4 rc4;
K1 = xzalloc(16);
K3 = xzalloc(16);
len = msg->length;
edata = xzalloc(len);
HMAC(EVP_md5(), (void*) key, 16, (uint8*) &msgtype, 4, (void*) K1, NULL);
HMAC(EVP_md5(), (void*) K1, 16, (uint8*) msg->data , 16, (void*) K3, NULL);
rc4 = crypto_rc4_init(K3, 16);
crypto_rc4(rc4, len - 16, (uint8*)(((uint8*) msg->data) + 16), (uint8*) edata->Confounder);
crypto_rc4_free(rc4);
HMAC(EVP_md5(), (void*) K1, 16, (uint8*)edata->Confounder, len - 16, (void*)&(edata->Checksum), NULL);
if(memcmp(msg->data, &edata->Checksum, 16))
{
xfree(edata) ;
xfree(K1) ;
xfree(K3) ;
return NULL;
}
decmsg = xnew(rdpBlob);
freerdp_blob_alloc(decmsg, len);
memcpy(decmsg->data, edata, len);
xfree(K1);
xfree(K3);
xfree(edata);
return decmsg;
}
rdpBlob* crypto_kdcmsg_encrypt_rc4(rdpBlob* msg, uint8* key, uint32 msgtype)
{
rdpBlob* encmsg;
uint8* K1;
uint8* K3;
uint32 len;
krbEdata* edata;
CryptoRc4 rc4;
K1 = xzalloc(16);
K3 = xzalloc(16);
len = ((msg->length > 16) ? msg->length : 16);
len += sizeof(krbEdata);
edata = xzalloc(len);
encmsg = xnew(rdpBlob);
freerdp_blob_alloc(encmsg, len);
HMAC(EVP_md5(), (void*) key, 16, (uint8*)&msgtype, 4, (void*) K1, NULL);
crypto_nonce((uint8*)(edata->Confounder), 8);
memcpy(&(edata->data[0]), msg->data, msg->length);
HMAC(EVP_md5(), (void*) K1, 16, (uint8*)edata->Confounder, len - 16, (void*)&(edata->Checksum), NULL);
HMAC(EVP_md5(), (void*) K1, 16, (uint8*)&(edata->Checksum), 16, (void*)K3, NULL);
memcpy(encmsg->data, &(edata->Checksum), 16);
rc4 = crypto_rc4_init(K3, 16);
crypto_rc4(rc4, len - 16, (uint8*) edata->Confounder, (uint8*)(((uint8*) encmsg->data) + 16));
crypto_rc4_free(rc4);
xfree(K1);
xfree(K3);
xfree(edata);
return encmsg;
}
void SteepestDescent (Vector & x, const MinFunction & fun,
const OptiParameters & par)
{
int it, n = x.Size();
Vector xnew(n), p(n), g(n), g2(n);
double val, alphahat;
int fail;
val = fun.FuncGrad(x, g);
alphahat = 1;
// testout << "f = ";
for (it = 0; it < 10; it++)
{
// testout << val << " ";
// p = -g;
p.Set (-1, g);
lines (x, xnew, p, val, g, fun, par, alphahat, -1e5,
0.1, 0.1, 1, 10, 0.1, 0.1, 0.6, fail);
x = xnew;
}
// testout << endl;
}
void *Blocktype_newf(size_t elsize)
{
Blocktype *b = xnew(Blocktype);
b->elsize = max(elsize, sizeof(void *));
b->free = 0;
return (void *)b;
}
int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters) {
assert(encoding != NULL);
iconv_t state = iconv_open(UTF_16_INTERNAL, encoding);
if (state == (iconv_t) -1) {
return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
}
ICONV_CONST char * input = (char *) bytes;
size_t input_bytes_left = num_bytes;
jschar * c = xnew(jschar, num_bytes);
char * output = (char *) c;
size_t output_bytes_left = sizeof(jschar) * num_bytes;
size_t result = iconv(state, &input, &input_bytes_left, &output, &output_bytes_left);
iconv_close(state);
if (result == (size_t) -1) {
free(c);
return JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE;
}
assert(input_bytes_left == 0);
size_t nc = ((jschar *) output) - c;
skip_bom(&c, &nc);
*characters = c;
*num_characters = nc;
return 0;
}
KrbAPREQ* krb_apreq_new(KRB_CONTEXT* krb_ctx, Ticket* ticket, Authenticator* krb_auth)
{
KrbAPREQ* krb_apreq;
STREAM* as;
rdpBlob msg;
rdpBlob* encmsg;
uint32 len;
as = stream_new(1024);
stream_seek(as, 1023);
krb_apreq = xnew(KrbAPREQ);
krb_apreq->pvno = KRB_VERSION;
krb_apreq->type = KRB_TAG_APREQ;
krb_apreq->ap_options = 0x00000000 | 0x00000000 | 0x00000000; /* Reserved (bit 31), Use session Key (bit 30), Mututal Required (bit 29) */
krb_apreq->ticket = ticket;
if (krb_auth != NULL)
{
len = krb_encode_authenticator(as, krb_auth);
msg.data = as->p;
msg.length = len;
encmsg = crypto_kdcmsg_encrypt(&msg, krb_ctx->askey, 7); /* RFC4757 section 3 for msgtype (T=7) */
krb_apreq->enc_auth.enctype = krb_ctx->askey->enctype;
krb_apreq->enc_auth.kvno = -1;
krb_apreq->enc_auth.encblob.data = encmsg->data;
krb_apreq->enc_auth.encblob.length = encmsg->length;
xfree(encmsg);
}
stream_free(as);
return krb_apreq;
}
Node *Node_new(int key, int value)
{
Node *self= xnew(Node);
self->key= key;
self->value= value;
return self;
}
static RDP_EVENT* freerdp_tsmf_event_new(uint16 event_type)
{
RDP_EVENT* event = NULL;
switch (event_type)
{
case RDP_EVENT_TYPE_TSMF_VIDEO_FRAME:
event = (RDP_EVENT*) xnew(RDP_VIDEO_FRAME_EVENT);
break;
case RDP_EVENT_TYPE_TSMF_REDRAW:
event = (RDP_EVENT*) xnew(RDP_REDRAW_EVENT);
break;
}
return event;
}
RDP_EVENT* freerdp_event_new(uint16 event_class, uint16 event_type,
RDP_EVENT_CALLBACK on_event_free_callback, void* user_data)
{
RDP_EVENT* event = NULL;
switch (event_class)
{
case RDP_EVENT_CLASS_DEBUG:
event = xnew(RDP_EVENT);
break;
case RDP_EVENT_CLASS_CLIPRDR:
event = freerdp_cliprdr_event_new(event_type);
break;
case RDP_EVENT_CLASS_TSMF:
event = freerdp_tsmf_event_new(event_type);
break;
case RDP_EVENT_CLASS_RAIL:
event = freerdp_rail_event_new(event_type);
break;
}
if (event != NULL)
{
event->event_class = event_class;
event->event_type = event_type;
event->on_event_free_callback = on_event_free_callback;
event->user_data = user_data;
}
return event;
}
rdpRpc* rpc_new(rdpTransport* transport)
{
rdpRpc* rpc = (rdpRpc*) xnew(rdpRpc);
if (rpc != NULL)
{
rpc->transport = transport;
rpc->settings = transport->settings;
rpc->send_seq_num = 0;
rpc->ntlm = ntlm_new();
rpc->ntlm_http_in = ntlm_http_new();
rpc->ntlm_http_out = ntlm_http_new();
rpc_ntlm_http_init_channel(rpc, rpc->ntlm_http_in, TSG_CHANNEL_IN);
rpc_ntlm_http_init_channel(rpc, rpc->ntlm_http_out, TSG_CHANNEL_OUT);
rpc->read_buffer = NULL;
rpc->write_buffer = NULL;
rpc->read_buffer_len = 0;
rpc->write_buffer_len = 0;
rpc->ReceiveWindow = 0x00010000;
rpc->VirtualConnection = rpc_client_virtual_connection_new(rpc);
rpc->call_id = 0;
}
return rpc;
}
static int dvcman_create_listener(IWTSVirtualChannelManager* pChannelMgr,
const char* pszChannelName, uint32 ulFlags,
IWTSListenerCallback* pListenerCallback, IWTSListener** ppListener)
{
DVCMAN* dvcman = (DVCMAN*)pChannelMgr;
DVCMAN_LISTENER* listener;
if (dvcman->num_listeners < MAX_PLUGINS)
{
DEBUG_DVC("%d.%s.", dvcman->num_listeners, pszChannelName);
listener = xnew(DVCMAN_LISTENER);
listener->iface.GetConfiguration = dvcman_get_configuration;
listener->dvcman = dvcman;
listener->channel_name = xstrdup(pszChannelName);
listener->flags = ulFlags;
listener->listener_callback = pListenerCallback;
if (ppListener)
*ppListener = (IWTSListener*)listener;
dvcman->listeners[dvcman->num_listeners++] = (IWTSListener*)listener;
return 0;
}
else
{
DEBUG_WARN("Maximum DVC listener number reached.");
return 1;
}
}
/* return a pointer of an initialized at_t
* if possible, initial values are taken from configuration
* file `cfg', otherwise default values are assumed */
static at_t *AdaptTempering_OpenCfg(const char *cfgname, double tmstep, int suffix)
{
cfgdata_t *cfg;
at_t *at;
bool bLoaded;
char *p;
int delay;
/* open configuration file */
die_if(!(cfg = cfgopen(cfgname)), "at_t: cannot open config. file %s.\n", cfgname);
/* allocate memory for at_t */
xnew(at, 1);
/* Get the file suffix first */
die_if(suffix >= 10, "do not support # of simulations > 10 currently\n");
at->suffix = (char)(((int)'0') + suffix);
/* call low level function */
die_if (!(bLoaded = at_cfgopen_low(at,cfg,tmstep)), "at_t: error while reading configuration file %s\n", cfgname);
printf("Successfully loaded cfg data!\n");
/* generate different random seeds in multi-simulation */
delay = suffix * 2;
sleep(delay);
/* load random number generator */
mtload(at->rng_file, 0);
/* close handle to configuration file */
cfgclose(cfg);
return at;
}
int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{
TSMF_PLUGIN * tsmf;
int error = 0;
tsmf = (TSMF_PLUGIN*) pEntryPoints->GetPlugin(pEntryPoints, "tsmf");
if (tsmf == NULL)
{
tsmf = xnew(TSMF_PLUGIN);
tsmf->iface.Initialize = tsmf_plugin_initialize;
tsmf->iface.Connected = NULL;
tsmf->iface.Disconnected = NULL;
tsmf->iface.Terminated = tsmf_plugin_terminated;
error = pEntryPoints->RegisterPlugin(pEntryPoints, "tsmf", (IWTSPlugin*) tsmf);
tsmf_media_init();
}
if (error == 0)
{
tsmf_process_plugin_data((IWTSPlugin*) tsmf,
pEntryPoints->GetPluginData(pEntryPoints));
}
return error;
}
int krb_tgsrep_recv(KRB_CONTEXT* krb_ctx)
{
int totlen, tmp, len;
int errcode;
STREAM* s;
KrbTGSREP* krb_tgsrep;
KrbKDCREP* kdc_rep;
errcode = -1;
s = stream_new(2048);
krb_tcp_recv(krb_ctx, s->data, s->size);
stream_read_uint32_be(s, totlen);
if(totlen >= 2044) // MALFORMED PACKET
goto finish;
if(((len = krb_decode_application_tag(s, KRB_TAG_TGSREP, &tmp)) == 0) || (tmp != (totlen - len))) //NOT AN TGS-REP
{
krb_ctx->state = KRB_PACKET_ERROR;
goto finish;
}
else /* TGS-REP process */
{
totlen -= len;
krb_tgsrep = xnew(KrbTGSREP);
krb_ctx->tgskey = xnew(KrbENCKey);
if(krb_decode_kdc_rep(s, &(krb_tgsrep->kdc_rep), totlen) == 0)
{
krb_ctx->state = KRB_PACKET_ERROR;
goto finish;
}
kdc_rep = &(krb_tgsrep->kdc_rep);
if(krb_verify_kdcrep(krb_ctx, kdc_rep, KRB_TAG_TGSREP) == 0)
krb_ctx->state = KRB_TGSREP_OK;
else
krb_ctx->state = KRB_PACKET_ERROR;
/* clean up */
krb_free_tgsrep(krb_tgsrep);
xfree(krb_tgsrep);
goto finish;
}
finish:
stream_free(s);
return errcode;
}
/**
* Allocates a new LIST structure.
* The list_*() API implements a chainlist and allows to store data of arbitrary type in FIFO mode.
* @see list_enqueue() to add elements to the list.
* @see list_dequeue() to remove the first element of the list and get a pointer to it.
* @see list_peek() to retrieve the first element of the list (and keep it there).
* @see list_free() to deallocate the list.
* @see list_size() to get the current number of elements in the list.
*
* @return A pointer to the allocated LIST structure. It must be deallocated by a call to list_free().
*
*/
LIST* list_new(void)
{
LIST* list;
list = xnew(LIST);
list->count = 0;
return list;
}
static LIST_ITEM* list_item_new(void* data)
{
LIST_ITEM* item;
item = xnew(LIST_ITEM);
item->data = data;
return item;
}
void *
Blocktype_newf (Bytecount elsize)
{
Blocktype *b = xnew (Blocktype);
b->elsize = max (elsize, (Bytecount) sizeof (void *));
b->free = 0;
return (void *) b;
}
at_t *AdaptTempering_NonMasterCreate()
{
at_t *at;
xnew(at, 1);
return at;
}
boolean df_pre_connect(freerdp* instance)
{
dfInfo* dfi;
dfContext* context;
rdpSettings* settings;
dfi = (dfInfo*) xzalloc(sizeof(dfInfo));
context = ((dfContext*) instance->context);
context->dfi = dfi;
settings = instance->settings;
settings->order_support[NEG_DSTBLT_INDEX] = true;
settings->order_support[NEG_PATBLT_INDEX] = true;
settings->order_support[NEG_SCRBLT_INDEX] = true;
settings->order_support[NEG_OPAQUE_RECT_INDEX] = true;
settings->order_support[NEG_DRAWNINEGRID_INDEX] = false;
settings->order_support[NEG_MULTIDSTBLT_INDEX] = false;
settings->order_support[NEG_MULTIPATBLT_INDEX] = false;
settings->order_support[NEG_MULTISCRBLT_INDEX] = false;
settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = true;
settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = false;
settings->order_support[NEG_LINETO_INDEX] = true;
settings->order_support[NEG_POLYLINE_INDEX] = true;
settings->order_support[NEG_MEMBLT_INDEX] = true;
settings->order_support[NEG_MEM3BLT_INDEX] = false;
settings->order_support[NEG_SAVEBITMAP_INDEX] = false;
settings->order_support[NEG_GLYPH_INDEX_INDEX] = false;
settings->order_support[NEG_FAST_INDEX_INDEX] = false;
settings->order_support[NEG_FAST_GLYPH_INDEX] = false;
settings->order_support[NEG_POLYGON_SC_INDEX] = false;
settings->order_support[NEG_POLYGON_CB_INDEX] = false;
settings->order_support[NEG_ELLIPSE_SC_INDEX] = false;
settings->order_support[NEG_ELLIPSE_CB_INDEX] = false;
dfi->clrconv = xnew(CLRCONV);
dfi->clrconv->alpha = 1;
dfi->clrconv->invert = 0;
dfi->clrconv->rgb555 = 0;
dfi->clrconv->palette = xnew(rdpPalette);
freerdp_channels_pre_connect(instance->context->channels, instance);
return true;
}
freerdp_listener* freerdp_listener_new(void)
{
freerdp_listener* instance;
rdpListener* listener;
instance = xnew(freerdp_listener);
instance->Open = freerdp_listener_open;
instance->GetFileDescriptor = freerdp_listener_get_fds;
instance->CheckFileDescriptor = freerdp_listener_check_fds;
instance->Close = freerdp_listener_close;
listener = xnew(rdpListener);
listener->instance = instance;
instance->listener = (void*)listener;
return instance;
}
