自学教程：C++ xnew函数代码示例

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

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

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