int
XdmcpWriteHeader (
XdmcpBufferPtr buffer,
XdmcpHeaderPtr header)
{
BYTE *newData;
if ((int)buffer->size < 6 + (int)header->length)
{
newData = (BYTE *) Xalloc (XDM_MAX_MSGLEN * sizeof (BYTE));
if (!newData)
return FALSE;
Xfree ((unsigned long *)(buffer->data));
buffer->data = newData;
buffer->size = XDM_MAX_MSGLEN;
}
buffer->pointer = 0;
if (!XdmcpWriteCARD16 (buffer, header->version))
return FALSE;
if (!XdmcpWriteCARD16 (buffer, header->opcode))
return FALSE;
if (!XdmcpWriteCARD16 (buffer, header->length))
return FALSE;
return TRUE;
}
pointer
XNFalloc (unsigned long amount)
{
register pointer ptr;
/* zero size requested */
if (amount == 0) {
LOG_ALLOC("XNFalloc=0", amount, 0);
return NULL;
}
/* negative size (or size > 2GB) - what do we do? */
if ((long)amount < 0) {
/* Diagnostic */
#ifdef FATALERRORS
FatalError("Xalloc: XNFalloc(<0)\n");
#else
ErrorF("Xalloc warning: XNFalloc(<0) ignored..\n");
#endif
LOG_ALLOC("XNFalloc<0", amount, 0);
return (unsigned long *)NULL;
}
ptr = Xalloc(amount);
if (!ptr)
{
FatalError("Out of memory");
}
return ptr;
}
pointer
Xcalloc(unsigned long n)
{
pointer r;
r = Xalloc(n);
memset(r, 0, n);
return r;
}
char *
debug_alloca(char *file, int line, int size)
{
char *ptr;
ptr = Xalloc(size);
ErrorF("Alloc: %s line %d; ptr = 0x%x, length = %d\n", file, line,
ptr, size);
return ptr;
}
pointer
XNFalloc(unsigned long n)
{
pointer r;
r = Xalloc(n);
if (!r)
FatalError("XNFalloc failed\n");
return r;
}
int
XdmcpAllocARRAYofARRAY8 (ARRAYofARRAY8Ptr array, int length)
{
ARRAY8Ptr newData;
newData = (ARRAY8Ptr) Xalloc (length * sizeof (ARRAY8));
if (!newData)
return FALSE;
array->length = length;
array->data = newData;
return TRUE;
}
int
XdmcpAllocARRAY16 (ARRAY16Ptr array, int length)
{
CARD16Ptr newData;
newData = (CARD16Ptr) Xalloc (length * sizeof (CARD16));
if (!newData)
return FALSE;
array->length = length;
array->data = newData;
return TRUE;
}
int
sisy_midi_file_init(sisy_t *sisy, char *midi_device)
{
unsigned char buff[BUFF_SIZE];
int size, t, tpqn, done;
midi_msg_t mmsg;
midi_t *file;
dbg(DBG_MIDI, "sisy_midi_file_init: start: ");
ck_err (!(file = midi_file_create (midi_device, MIDI_FLAG_GET)));
ck_err ((sisy->nb_tracks = midi_file_get_nb_tracks(file)) < 0);
ck_err (!(sisy->tracks=Xalloc(sisy_track_t, sisy->nb_tracks)));
ck_err (midi_tpqn_set(tpqn=midi_file_get_tpqn(file)));
for(t=0; t<sisy->nb_tracks; t++)
{
sisy_track_t *track=&sisy->tracks[t];
if(dbg_filter&DBG_MIDI)
printf("midi new track\n");
ck_err(!(track->midi.midi = midi_pipe_create (0)));
ck_err (sisy_track_init(track) < 0);
done=0;
while(!done)
{
ck_err(midi_get_msg (file, &mmsg)<0);
if(dbg_filter&DBG_MIDI)
printf("sisy_midi_track_init: %x\n", MIDI_MSG_STATUS(&mmsg));
if (MIDI_MSG_DATA (&mmsg))
{
ck_err ((size=midi_get_data (file, buff, BUFF_SIZE-1)) < 0);
buff[size]=0;
if(dbg_filter&DBG_MIDI)
printf("midi data(%d): %s\n", size, buff);
continue;
}
if(MIDI_MSG_EOT (&mmsg))
{
mmsg.timestamp += tpqn*4;
done=1;
}
ck_err(midi_put_msg(track->midi.midi, &mmsg) < 0);
}
dbg(DBG_MIDI, "sisy_midi_file_init: EOT\n");
}
midi_destroy(file);
return 0;
error:
return -1;
}
char *
Xstrdup(const char *s)
{
char *sd;
if (s == NULL)
return NULL;
sd = (char *)Xalloc(strlen(s) + 1);
if (sd != NULL)
strcpy(sd, s);
return sd;
}
boolean vm_init()
{
vm_next = vm_base = (char *) Xalloc(MAX_STRING_LEN);
if (vm_base != NULL) {
vm_free = MAX_STRING_LEN;
vm_size = MAX_STRING_LEN;
tokenMaxP = vm_next_byte() + MAX_STRING_LEN;
return(TRUE);
}
else
return(FALSE);
}
pointer
Xcalloc (unsigned long amount)
{
pointer ret;
ret = Xalloc (amount);
if (ret != 0
#if defined(HAS_MMAP_ANON) || defined(MMAP_DEV_ZERO)
&& (amount < MIN_LARGE) /* mmaped anonymous mem is already cleared */
#endif
)
bzero ((char *) ret, (int) amount);
return ret;
}
static int
ProcXCMiscGetXIDList(ClientPtr client)
{
REQUEST(xXCMiscGetXIDListReq);
xXCMiscGetXIDListReply rep;
int n;
XID *pids;
unsigned int count;
REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);
if (stuff->count > UINT32_MAX / sizeof(XID))
return BadAlloc;
pids = (XID *)Xalloc(stuff->count * sizeof(XID));
if (!pids)
{
return BadAlloc;
}
count = GetXIDList(client, stuff->count, pids);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = count;
rep.count = count;
if (client->swapped) {
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swapl(&rep.count, n);
}
WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep);
if (count)
{
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, count * sizeof(XID), pids);
}
Xfree(pids);
return(client->noClientException);
}
static CharInfoRec *
CIDGetCharMetrics(FontPtr pFont, FontInfo *fi, unsigned int charcode, double sxmult)
{
CharInfoPtr cp;
Metrics *p, node;
unsigned int cidcode;
cidcode = node.code = getCID(pFont, charcode);
if ((cidcode < fi->nChars) && (cidcode == fi->metrics[cidcode].code))
p = &fi->metrics[cidcode];
else
p = (Metrics *)bsearch(&node, fi->metrics, fi->nChars, sizeof(Metrics), node_compare);
if (!p)
p = &fi->metrics[0];
if (!(cp = (CharInfoRec *)Xalloc(sizeof(CharInfoRec))))
return NULL;
bzero(cp, sizeof(CharInfoRec));
/* indicate that character bitmap is not defined */
cp->bits = (char *)CID_BITMAP_UNDEFINED;
/* get metric data for this CID code from the CID AFM file */
cp->metrics.leftSideBearing =
floor(p->charBBox.llx / sxmult + 0.5);
cp->metrics.rightSideBearing =
floor(p->charBBox.urx / sxmult + 0.5);
cp->metrics.characterWidth = floor(p->wx / sxmult + 0.5);
cp->metrics.ascent = floor(p->charBBox.ury / sxmult + 0.5);
cp->metrics.descent = -floor(p->charBBox.lly / sxmult + 0.5);
cp->metrics.attributes = p->wx;
return cp;
}
static void CalcServerVersionAndExtensions( void )
{
int s;
xGLXQueryVersionReq *req;
xGLXQueryVersionReply reply;
char **be_extensions;
char *ext;
char *denied_extensions;
/*
* set the server glx version to be the minimum version
* supported by all back-end servers
*/
__glXVersionMajor = 0;
__glXVersionMinor = 0;
for (s=0; s<__glXNumActiveScreens; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = dmxScreen->beDisplay;
/* Send the glXQueryVersion request */
LockDisplay(dpy);
GetReq(GLXQueryVersion,req);
req->reqType = dmxScreen->glxMajorOpcode;
req->glxCode = X_GLXQueryVersion;
req->majorVersion = GLX_SERVER_MAJOR_VERSION;
req->minorVersion = GLX_SERVER_MINOR_VERSION;
_XReply(dpy, (xReply*) &reply, 0, False);
UnlockDisplay(dpy);
SyncHandle();
if (s == 0) {
__glXVersionMajor = reply.majorVersion;
__glXVersionMinor = reply.minorVersion;
}
else {
if (reply.majorVersion < __glXVersionMajor) {
__glXVersionMajor = reply.majorVersion;
__glXVersionMinor = reply.minorVersion;
}
else if ( (reply.majorVersion == __glXVersionMajor) &&
(reply.minorVersion < __glXVersionMinor) ) {
__glXVersionMinor = reply.minorVersion;
}
}
}
if (GLX_SERVER_MAJOR_VERSION < __glXVersionMajor) {
__glXVersionMajor = GLX_SERVER_MAJOR_VERSION;
__glXVersionMinor = GLX_SERVER_MINOR_VERSION;
}
else if ( (GLX_SERVER_MAJOR_VERSION == __glXVersionMajor) &&
(GLX_SERVER_MINOR_VERSION < __glXVersionMinor) ) {
__glXVersionMinor = GLX_SERVER_MINOR_VERSION;
}
sprintf(GLXServerVersion, "%d.%d DMX %d back-end server(s)",
__glXVersionMajor, __glXVersionMinor, __glXNumActiveScreens );
/*
* set the ExtensionsString to the minimum extensions string
*/
ExtensionsString[0] = '\0';
/*
* read extensions strings of all back-end servers
*/
be_extensions = (char **)Xalloc( __glXNumActiveScreens * sizeof(char *) );
if (!be_extensions)
return;
for (s=0; s<__glXNumActiveScreens; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
Display *dpy = dmxScreen->beDisplay;
xGLXQueryServerStringReq *req;
xGLXQueryServerStringReply reply;
int length, numbytes, slop;
/* Send the glXQueryServerString request */
LockDisplay(dpy);
GetReq(GLXQueryServerString,req);
req->reqType = dmxScreen->glxMajorOpcode;
req->glxCode = X_GLXQueryServerString;
req->screen = DefaultScreen(dpy);
req->name = GLX_EXTENSIONS;
_XReply(dpy, (xReply*) &reply, 0, False);
length = (int)reply.length;
numbytes = (int)reply.n;
slop = numbytes * __GLX_SIZE_INT8 & 3;
be_extensions[s] = (char *)Xalloc(numbytes);
if (!be_extensions[s]) {
/* Throw data on the floor */
_XEatData(dpy, length);
} else {
_XRead(dpy, (char *)be_extensions[s], numbytes);
if (slop) _XEatData(dpy,4-slop);
}
UnlockDisplay(dpy);
SyncHandle();
}
/*
* extensions string will include only extensions that our
* server supports as well as all back-end servers supports.
* extensions that are in the DMX_DENY_EXTENSIONS string will
* not be supported.
*/
denied_extensions = getenv("DMX_DENY_GLX_EXTENSIONS");
ext = strtok(GLXServerExtensions, " ");
while( ext ) {
int supported = 1;
if (denied_extensions && strstr(denied_extensions, ext)) {
supported = 0;
}
else {
for (s=0; s<__glXNumActiveScreens && supported; s++) {
if ( !strstr(be_extensions[s], ext) ) {
supported = 0;
}
}
}
if (supported) {
strcat(ExtensionsString, ext);
strcat(ExtensionsString, " ");
}
ext = strtok(NULL, " ");
}
/*
* release temporary storage
*/
for (s=0; s<__glXNumActiveScreens; s++) {
if (be_extensions[s]) Xfree(be_extensions[s]);
}
Xfree( be_extensions );
if (dmxGLXSwapGroupSupport) {
if (!denied_extensions ||
!strstr(denied_extensions, "GLX_SGIX_swap_group")) {
strcat(ExtensionsString, "GLX_SGIX_swap_group");
if (!denied_extensions ||
!strstr(denied_extensions, "GLX_SGIX_swap_barrier")) {
strcat(ExtensionsString, " GLX_SGIX_swap_barrier");
}
}
}
}
void __glXScreenInit(GLint numscreens)
{
int s;
int c;
DMXScreenInfo *dmxScreen0 = &dmxScreens[0];
__glXNumActiveScreens = numscreens;
CalcServerVersionAndExtensions();
__glXFBConfigs = NULL;
__glXNumFBConfigs = 0;
if ( (__glXVersionMajor == 1 && __glXVersionMinor >= 3) ||
(__glXVersionMajor > 1) ||
( strstr(ExtensionsString, "GLX_SGIX_fbconfig") ) ) {
/*
// Initialize FBConfig info.
// find the set of FBConfigs that are present on all back-end
// servers - only those configs will be supported
*/
__glXFBConfigs = (__GLXFBConfig **)Xalloc( dmxScreen0->numFBConfigs *
(numscreens+1) * sizeof(__GLXFBConfig *) );
__glXNumFBConfigs = 0;
for (c=0; c<dmxScreen0->numFBConfigs; c++) {
__GLXFBConfig *cfg = NULL;
if (numscreens > 1) {
for (s=1; s<numscreens; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
__GLXscreenInfo *glxScreen = &__glXActiveScreens[s];
cfg = FindMatchingFBConfig( &dmxScreen0->fbconfigs[c],
dmxScreen->fbconfigs,
dmxScreen->numFBConfigs );
__glXFBConfigs[ __glXNumFBConfigs * (numscreens+1) + s + 1 ] = cfg;
if (!cfg) {
dmxLog(dmxInfo,"screen0 FBConfig 0x%x is missing on screen#%d\n", dmxScreen0->fbconfigs[c].id, s);
break;
}
else {
dmxLog(dmxInfo,"screen0 FBConfig 0x%x matched to 0x%x on screen#%d\n", dmxScreen0->fbconfigs[c].id, cfg->id, s);
}
}
}
else {
cfg = &dmxScreen0->fbconfigs[c];
}
if (cfg) {
/* filter out overlay visuals */
if (cfg->level == 0) {
__GLXFBConfig *proxy_cfg;
__glXFBConfigs[ __glXNumFBConfigs * (numscreens+1) + 1 ] =
&dmxScreen0->fbconfigs[c];
proxy_cfg = Xalloc( sizeof(__GLXFBConfig) );
memcpy( proxy_cfg, cfg, sizeof(__GLXFBConfig) );
proxy_cfg->id = FakeClientID(0);
/* visual will be associated later in __glXGetFBConfigs */
proxy_cfg->associatedVisualId = (unsigned int)-1;
__glXFBConfigs[ __glXNumFBConfigs * (numscreens+1) + 0 ] = proxy_cfg;
__glXNumFBConfigs++;
}
}
}
}
}
void *
Xrealloc (pointer ptr, unsigned long amount)
{
register unsigned long *new_ptr;
/* zero size requested */
if (amount == 0) {
if (ptr)
Xfree(ptr);
LOG_REALLOC("Xrealloc=0", ptr, amount, 0);
return NULL;
}
/* negative size (or size > 2GB) - what do we do? */
if ((long)amount < 0) {
/* Diagnostic */
#ifdef FATALERRORS
FatalError("Xalloc: Xrealloc(<0)\n");
#else
ErrorF("Xalloc warning: Xrealloc(<0) ignored..\n");
#endif
if (ptr)
Xfree(ptr); /* ?? */
LOG_REALLOC("Xrealloc<0", ptr, amount, 0);
return NULL;
}
new_ptr = Xalloc(amount);
if ( (new_ptr) && (ptr) ) {
unsigned long old_size;
old_size = ((unsigned long *)ptr)[-2];
#ifdef XALLOC_DEBUG
if (MAGIC != ((unsigned long *)ptr)[-1]) {
if (MAGIC_FREE == ((unsigned long *)ptr)[-1]) {
#ifdef FATALERRORS
XfreeTrap();
FatalError("Xalloc error: range already freed in Xrealloc() :-(\n");
#else
ErrorF("Xalloc error: range already freed in Xrealloc() :-(\a\n");
sleep(5);
XfreeTrap();
#endif
LOG_REALLOC("Xalloc error: ranged already freed in Xrealloc() :-(",
ptr, amount, 0);
return NULL;
}
#ifdef FATALERRORS
XfreeTrap();
FatalError("Xalloc error: header corrupt in Xrealloc() :-(\n");
#else
ErrorF("Xalloc error: header corrupt in Xrealloc() :-(\n");
XfreeTrap();
#endif
LOG_REALLOC("Xalloc error: header corrupt in Xrealloc() :-(",
ptr, amount, 0);
return NULL;
}
#endif /* XALLOC_DEBUG */
/* copy min(old size, new size) */
memcpy((char *)new_ptr, (char *)ptr, (amount < old_size ? amount : old_size));
}
if (ptr)
Xfree(ptr);
if (new_ptr) {
LOG_REALLOC("Xrealloc", ptr, amount, new_ptr);
return (void *)new_ptr;
}
if (Must_have_memory)
FatalError("Out of memory");
LOG_REALLOC("Xrealloc", ptr, amount, 0);
return NULL;
}