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