int
PsIsISOLatin1Encoding(FontPtr pFont)
{
int i;
int nprops = pFont->info.nprops;
FontPropPtr props = pFont->info.props;
Atom reg = MakeAtom("CHARSET_REGISTRY", 16, True);
Atom enc = MakeAtom("CHARSET_ENCODING", 16, True);
Atom rv = 0, ev = 0;
char *rp = 0;
char *ep = 0;
for( i=0 ; i<nprops ; i++ )
{
if( props[i].name==reg ) rv = props[i].value;
if( props[i].name==enc ) ev = props[i].value;
}
if( rv ) rp = NameForAtom(rv);
if( ev ) ep = NameForAtom(ev);
if( (!rp) || (!ep) ) return(0);
if( (char)tolower(rp[0])!='i' ||
(char)tolower(rp[1])!='s' ||
(char)tolower(rp[2])!='o' ||
memcmp(&rp[3], "8859", 4)!=0 ||
ep[0]!='1' ) return(0);
return(1);
}
static int
ephyrSetPortAttribute(KdScreenInfo * a_info,
Atom a_attr_name, int a_attr_value, pointer a_port_priv)
{
int res = Success, host_atom = 0;
EphyrPortPriv *port_priv = a_port_priv;
Bool is_attr_valid = FALSE;
EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);
EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor, BadMatch);
EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->pAttributes, BadMatch);
EPHYR_RETURN_VAL_IF_FAIL(port_priv->current_adaptor->nAttributes, BadMatch);
EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);
EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s, attr_val:%d\n",
port_priv->port_number,
(int) a_attr_name, NameForAtom(a_attr_name), a_attr_value);
if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {
EPHYR_LOG_ERROR("failed to convert local atom to host atom\n");
res = BadMatch;
goto out;
}
if (!ephyrXVPrivIsAttrValueValid(port_priv->current_adaptor->pAttributes,
port_priv->current_adaptor->nAttributes,
NameForAtom(a_attr_name),
a_attr_value, &is_attr_valid)) {
EPHYR_LOG_ERROR("failed to validate attribute %s\n",
NameForAtom(a_attr_name));
/*
res = BadMatch ;
goto out ;
*/
}
if (!is_attr_valid) {
EPHYR_LOG_ERROR("attribute %s is not valid\n",
NameForAtom(a_attr_name));
/*
res = BadMatch ;
goto out ;
*/
}
if (!ephyrHostXVSetPortAttribute(port_priv->port_number,
host_atom, a_attr_value)) {
EPHYR_LOG_ERROR("failed to set port attribute\n");
res = BadMatch;
goto out;
}
res = Success;
out:
EPHYR_LOG("leave\n");
return res;
}
Bool
PsIsFreeTypeFont(FontPtr pFont)
{
int i;
int nprops = pFont->info.nprops;
FontPropPtr props = pFont->info.props;
/* "RASTERIZER_NAME" must match the rasterizer name set in
* xc/lib/font/FreeType/ftfuncs.c */
Atom name = MakeAtom("RASTERIZER_NAME", 15, True);
Atom value = (Atom)0;
char *rv;
for( i=0 ; i<nprops ; i++ )
{
if( props[i].name==name )
{ value = props[i].value; break; }
}
if( !value )
return False;
rv = NameForAtom(value);
if( !rv )
return False;
if( memcmp(rv, "FreeType", 8) == 0 )
return True;
return False;
}
int
XrandrAuthorizeRequest(ClientPtr client, ExtensionEntry *ext)
{
unsigned short opcode = StandardMinorOpcode(client);
ClientPolicyPtr policy = ClientGetPolicyRec(client);
switch (opcode) {
case X_RRChangeOutputProperty:
{
REQUEST(xRRChangeOutputPropertyReq);
PolicyDebug("client %p (pid %u exe '%s') requested RandR "
"ChangeOutputProperty '%s'", client, policy->pid,
policy->exe, NameForAtom(stuff->property));
}
break;
default:
PolicyDebug("client %p (pid %u exe '%s') requested RandR %s",
client, policy->pid, policy->exe, RequestName(opcode));
break;
}
return Success;
}
static int
ephyrGetPortAttribute(KdScreenInfo * a_screen_info,
Atom a_attr_name, int *a_attr_value, pointer a_port_priv)
{
int res = Success, host_atom = 0;
EphyrPortPriv *port_priv = a_port_priv;
EPHYR_RETURN_VAL_IF_FAIL(port_priv, BadMatch);
EPHYR_RETURN_VAL_IF_FAIL(ValidAtom(a_attr_name), BadMatch);
EPHYR_LOG("enter, portnum:%d, atomid:%d, attr_name:%s\n",
port_priv->port_number,
(int) a_attr_name, NameForAtom(a_attr_name));
if (!ephyrLocalAtomToHost(a_attr_name, &host_atom)) {
EPHYR_LOG_ERROR("failed to convert local atom to host atom\n");
res = BadMatch;
goto out;
}
if (!ephyrHostXVGetPortAttribute(port_priv->port_number,
host_atom, a_attr_value)) {
EPHYR_LOG_ERROR("failed to get port attribute\n");
res = BadMatch;
goto out;
}
res = Success;
out:
EPHYR_LOG("leave\n");
return res;
}
/*
* Looks up a name in the selection or property mappings
*/
static int
SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec * obj, int map, int polymap)
{
const char *name = NameForAtom(atom);
security_context_t ctx;
int rc = Success;
obj->poly = 1;
/* Look in the mappings of names to contexts */
if (selabel_lookup_raw(label_hnd, &ctx, name, map) == 0) {
obj->poly = 0;
}
else if (errno != ENOENT) {
ErrorF("SELinux: a property label lookup failed!\n");
return BadValue;
}
else if (selabel_lookup_raw(label_hnd, &ctx, name, polymap) < 0) {
ErrorF("SELinux: a property label lookup failed!\n");
return BadValue;
}
/* Get a SID for context */
if (avc_context_to_sid_raw(ctx, &obj->sid) < 0) {
ErrorF("SELinux: a context_to_SID_raw call failed!\n");
rc = BadAlloc;
}
freecon(ctx);
return rc;
}
Bool
bdfSpecialProperty(FontPtr pFont, FontPropPtr prop,
char isString, bdfFileState *bdfState)
{
char **special;
char *name;
name = NameForAtom(prop->name);
for (special = SpecialAtoms; *special; special++)
if (!strcmp(name, *special))
break;
switch (special - SpecialAtoms) {
case BDF_FONT_ASCENT:
if (!isString) {
pFont->info.fontAscent = prop->value;
bdfState->haveFontAscent = TRUE;
}
return TRUE;
case BDF_FONT_DESCENT:
if (!isString) {
pFont->info.fontDescent = prop->value;
bdfState->haveFontDescent = TRUE;
}
return TRUE;
case BDF_DEFAULT_CHAR:
if (!isString) {
pFont->info.defaultCh = prop->value;
bdfState->haveDefaultCh = TRUE;
}
return TRUE;
case BDF_POINT_SIZE:
bdfState->pointSizeProp = prop;
return FALSE;
case BDF_RESOLUTION:
bdfState->resolutionProp = prop;
return FALSE;
case BDF_X_HEIGHT:
bdfState->xHeightProp = prop;
return FALSE;
case BDF_WEIGHT:
bdfState->weightProp = prop;
return FALSE;
case BDF_QUAD_WIDTH:
bdfState->quadWidthProp = prop;
return FALSE;
case BDF_FONT:
bdfState->fontProp = prop;
return FALSE;
case BDF_RESOLUTION_X:
bdfState->resolutionXProp = prop;
return FALSE;
case BDF_RESOLUTION_Y:
bdfState->resolutionYProp = prop;
return FALSE;
default:
return FALSE;
}
}
char *
PsGetFontName(FontPtr pFont)
{
int i;
int nprops = pFont->info.nprops;
FontPropPtr props = pFont->info.props;
Atom name = MakeAtom("FONT", 4, True);
Atom value = (Atom)0;
for( i=0 ; i<nprops ; i++ )
{
if( props[i].name==name )
{ value = props[i].value; break; }
}
if( !value ) return (char *)0;
return NameForAtom(value);
}
char *
PsGetPSFontName(FontPtr pFont)
{
int i;
int nprops = pFont->info.nprops;
FontPropPtr props = pFont->info.props;
Atom name = MakeAtom("_ADOBE_POSTSCRIPT_FONTNAME", 26, True);
Atom value = (Atom)0;
for( i=0 ; i<nprops ; i++ )
{
if( props[i].name==name )
{ value = props[i].value; break; }
}
if( !value ) return "Times-Roman";
return NameForAtom(value);
}
Bool
xnestRealizeFont(ScreenPtr pScreen, FontPtr pFont)
{
pointer priv;
Atom name_atom, value_atom;
int nprops;
FontPropPtr props;
int i;
char *name;
FontSetPrivate(pFont, xnestFontPrivateIndex, NULL);
if (requestingClient && XpClientIsPrintClient(requestingClient, NULL))
return True;
name_atom = MakeAtom("FONT", 4, True);
value_atom = 0L;
nprops = pFont->info.nprops;
props = pFont->info.props;
for (i = 0; i < nprops; i++)
if (props[i].name == name_atom) {
value_atom = props[i].value;
break;
}
if (!value_atom) return False;
name = (char *)NameForAtom(value_atom);
if (!name) return False;
priv = (pointer)xalloc(sizeof(xnestPrivFont));
FontSetPrivate(pFont, xnestFontPrivateIndex, priv);
xnestFontPriv(pFont)->font_struct = XLoadQueryFont(xnestDisplay, name);
if (!xnestFontStruct(pFont)) return False;
return True;
}
static void
SecurityProperty(CallbackListPtr *pcbl, pointer unused, pointer calldata)
{
XacePropertyAccessRec *rec = calldata;
SecurityStateRec *subj, *obj;
ATOM name = (*rec->ppProp)->propertyName;
Mask requested = rec->access_mode;
Mask allowed = SecurityResourceMask | DixReadAccess;
subj = dixLookupPrivate(&rec->client->devPrivates, stateKey);
obj = dixLookupPrivate(&wClient(rec->pWin)->devPrivates, stateKey);
if (SecurityDoCheck(subj, obj, requested, allowed) != Success) {
SecurityAudit("Security: denied client %d access to property %s "
"(atom 0x%x) window 0x%x of client %d on request %s\n",
rec->client->index, NameForAtom(name), name,
rec->pWin->drawable.id, wClient(rec->pWin)->index,
SecurityLookupRequestName(rec->client));
rec->status = BadAccess;
}
}
static Bool
ephyrLocalAtomToHost(int a_local_atom, int *a_host_atom)
{
const char *atom_name = NULL;
int host_atom = None;
EPHYR_RETURN_VAL_IF_FAIL(a_host_atom, FALSE);
if (!ValidAtom(a_local_atom))
return FALSE;
atom_name = NameForAtom(a_local_atom);
if (!atom_name)
return FALSE;
if (!ephyrHostGetAtom(atom_name, FALSE, &host_atom) || host_atom == None) {
EPHYR_LOG_ERROR("no atom for string %s defined in host X\n", atom_name);
return FALSE;
}
*a_host_atom = host_atom;
return TRUE;
}
/** Load the font, \a pFont, on the back-end server associated with \a
* pScreen. When a font is loaded, the font path on back-end server is
* first initialized to that specified on the command line with the
* -fontpath options, and then the font is loaded. */
Bool
dmxBELoadFont(ScreenPtr pScreen, FontPtr pFont)
{
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
dmxFontPrivPtr pFontPriv = FontGetPrivate(pFont, dmxFontPrivateIndex);
const char *name;
char **oldFontPath = NULL;
int nOldPaths;
Atom name_atom, value_atom;
int i;
/* Make sure we have a font private struct to work with */
if (!pFontPriv)
return FALSE;
/* Don't load a font over top of itself */
if (pFontPriv->font[pScreen->myNum]) {
return TRUE; /* Already loaded font */
}
/* Save old font path */
oldFontPath = XGetFontPath(dmxScreen->beDisplay, &nOldPaths);
/* Set the font path for the font about to be loaded on the back-end */
if (dmxSetFontPath(dmxScreen)) {
char **fp;
int npaths;
Bool *goodfps;
/* This could fail only when first starting the X server and
* loading the default font. If it fails here, then the default
* font path is invalid, no default font path will be set, the
* DMX server will fail to load the default font, and it will
* exit with an error unless we remove the offending font paths
* with the -ignorebadfontpaths command line option.
*/
fp = dmxGetFontPath(&npaths);
if (!fp) {
dmxLog(dmxError, "No default font path set.\n");
dmxLog(dmxError,
"Please see the Xdmx man page for information on how to\n");
dmxLog(dmxError,
"initialize the DMX server's default font path.\n");
XFreeFontPath(oldFontPath);
return FALSE;
}
if (!dmxFontPath)
dmxLog(dmxWarning, "No default font path is set.\n");
goodfps = xallocarray(npaths, sizeof(*goodfps));
dmxLog(dmxError,
"The DMX server failed to set the following font paths on "
"screen #%d:\n", pScreen->myNum);
for (i = 0; i < npaths; i++)
if (!(goodfps[i] = dmxCheckFontPathElement(dmxScreen, fp[i])))
dmxLog(dmxError, " %s\n", fp[i]);
if (dmxIgnoreBadFontPaths) {
char *newfp;
int newnpaths = 0;
int len = 0;
int j = 0;
dmxLog(dmxError,
"These font paths will not be used because the "
"\"-ignorebadfontpaths\"\n");
dmxLog(dmxError, "option is set.\n");
for (i = 0; i < npaths; i++)
if (goodfps[i]) {
len += strlen(fp[i]) + 1;
newnpaths++;
}
if (!newnpaths) {
/* No valid font paths were found */
dmxLog(dmxError,
"After removing the font paths above, no valid font "
"paths were\n");
dmxLog(dmxError,
"available. Please check that the font paths set on "
"the command\n");
dmxLog(dmxError,
"line or in the configuration file via the "
"\"-fontpath\" option\n");
dmxLog(dmxError,
"are valid on all back-end servers. See the Xdmx man "
"page for\n");
dmxLog(dmxError, "more information on font paths.\n");
dmxFreeFontPath(fp);
XFreeFontPath(oldFontPath);
free(goodfps);
return FALSE;
}
newfp = xallocarray(len, sizeof(*newfp));
for (i = 0; i < npaths; i++) {
if (goodfps[i]) {
int n = strlen(fp[i]);
newfp[j++] = n;
strncpy(&newfp[j], fp[i], n);
j += n;
}
}
if (SetFontPath(serverClient, newnpaths, (unsigned char *) newfp)) {
/* Note that this should never happen since all of the
* FPEs were previously valid. */
dmxLog(dmxError, "Cannot reset the default font path.\n");
}
}
else if (dmxFontPath) {
dmxLog(dmxError,
"Please remove these font paths from the command line "
"or\n");
dmxLog(dmxError,
"configuration file, or set the \"-ignorebadfontpaths\" "
"option to\n");
dmxLog(dmxError,
"ignore them. For more information on these options, see "
"the\n");
dmxLog(dmxError, "Xdmx man page.\n");
}
else {
dmxLog(dmxError,
"Please specify the font paths that are available on all "
"back-end\n");
dmxLog(dmxError,
"servers with the \"-fontpath\" option, or use the "
"\"-ignorebadfontpaths\"\n");
dmxLog(dmxError,
"to ignore bad defaults. For more information on "
"these and other\n");
dmxLog(dmxError,
"font-path-related options, see the Xdmx man page.\n");
}
free(goodfps);
if (!dmxIgnoreBadFontPaths ||
(dmxIgnoreBadFontPaths && dmxSetFontPath(dmxScreen))) {
/* We still have errors so return with error */
dmxFreeFontPath(fp);
XFreeFontPath(oldFontPath);
return FALSE;
}
}
/* Find requested font on back-end server */
name_atom = MakeAtom("FONT", 4, TRUE);
value_atom = 0L;
for (i = 0; i < pFont->info.nprops; i++) {
if ((Atom) pFont->info.props[i].name == name_atom) {
value_atom = pFont->info.props[i].value;
break;
}
}
if (!value_atom)
return FALSE;
name = NameForAtom(value_atom);
if (!name)
return FALSE;
pFontPriv->font[pScreen->myNum] =
XLoadQueryFont(dmxScreen->beDisplay, name);
/* Restore old font path */
XSetFontPath(dmxScreen->beDisplay, oldFontPath, nOldPaths);
XFreeFontPath(oldFontPath);
dmxSync(dmxScreen, FALSE);
if (!pFontPriv->font[pScreen->myNum])
return FALSE;
return TRUE;
}
static Bool
drmmode_output_set_property(xf86OutputPtr output, Atom property,
RRPropertyValuePtr value)
{
drmmode_output_private_ptr drmmode_output = output->driver_private;
drmmode_ptr drmmode = drmmode_output->drmmode;
int i;
if (property == backlight_atom || property == backlight_deprecated_atom) {
INT32 val;
if (value->type != XA_INTEGER || value->format != 32 ||
value->size != 1)
{
return FALSE;
}
val = *(INT32 *)value->data;
if (val < 0 || val > drmmode_output->backlight_max)
return FALSE;
if (drmmode_output->dpms_mode == DPMSModeOn)
drmmode_backlight_set(output, val);
drmmode_output->backlight_active_level = val;
return TRUE;
}
for (i = 0; i < drmmode_output->num_props; i++) {
drmmode_prop_ptr p = &drmmode_output->props[i];
if (p->atoms[0] != property)
continue;
if (p->mode_prop->flags & DRM_MODE_PROP_RANGE) {
uint32_t val;
if (value->type != XA_INTEGER || value->format != 32 ||
value->size != 1)
return FALSE;
val = *(uint32_t *)value->data;
drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id,
p->mode_prop->prop_id, (uint64_t)val);
return TRUE;
} else if (p->mode_prop->flags & DRM_MODE_PROP_ENUM) {
Atom atom;
const char *name;
int j;
if (value->type != XA_ATOM || value->format != 32 || value->size != 1)
return FALSE;
memcpy(&atom, value->data, 4);
name = NameForAtom(atom);
/* search for matching name string, then set its value down */
for (j = 0; j < p->mode_prop->count_enums; j++) {
if (!strcmp(p->mode_prop->enums[j].name, name)) {
drmModeConnectorSetProperty(drmmode->fd, drmmode_output->output_id,
p->mode_prop->prop_id, p->mode_prop->enums[j].value);
return TRUE;
}
}
return FALSE;
}
}
return TRUE;
}
