/*
* Split a registry key name into its root name (setting rkey)
* returning a pointer to the rest.
* If connection to a remote computer has been specified rkey is
* set to that machine's handle.
* In that case the returned rkey must be passed to a call to RegCloseKey
*/
static char *
split_name(char *name, HKEY *rkey, char *rname)
{
char *s, *p;
LONG ret;
for (s = name, p = rname; *s && *s != '\\'; s++, p++)
*p = *s;
*p = '\0';
if (*s == '\\')
s++;
if (nameval(handles, sizeof(handles) / sizeof(struct s_nameval), rname, (DWORD *)rkey)) {
if (remote) {
/* Redirect to the remote machine */
if ((ret = RegConnectRegistry(remote, *rkey, rkey)) != ERROR_SUCCESS)
wperror(remote, ret);
}
return (*s ? s : NULL);
} else {
fprintf(stderr, "Unknown root handle name [%s]\n", rname);
exit(1);
}
}
/*
* give variable at `vp' the value `val'.
*/
void setval(struct var *vp, const char *val)
{
nameval(vp, val, NULL);
}
/*
* Process formated input containing registry data adding keys to the
* registry
*/
static void
input_process(void)
{
/* Read and add keys */
char *name;
char type[100];
unsigned char *data;
int namelen, datalen;
int nameidx, typeidx, dataidx = 0;
enum {SNAME = 1000, STYPE, REG_BINARY2, REG_SZ_BACK, REG_SZ_HEX, REG_SZ_HEX2}
state;
int c;
DWORD typeval;
int hexcount;
name = malloc(namelen = 32);
data = malloc(datalen = 32);
state = SNAME;
nameidx = 0;
line = 1;
while ((c = getchar()) != EOF) {
if (dataidx >= datalen)
data = realloc(data, datalen *= 2);
switch (state) {
case SNAME:
if (nameidx >= namelen)
name = realloc(name, namelen *= 2);
if (c == field_sep) {
name[nameidx++] = '\0';
state = STYPE;
typeidx = 0;
} else if (c == '\n') {
fprintf(stderr, "Missing type in line %d\n", line);
exit(1);
} else
name[nameidx++] = c;
break;
case STYPE:
if (c == field_sep) {
type[typeidx++] = '\0';
dataidx = 0;
if (!nameval(types, sizeof(types) / sizeof(struct s_nameval), type, &typeval)) {
fprintf(stderr, "Line %d: Unrecognized type name\n", line);
exit(1);
}
state = typeval;
} else if (c == '\n') {
fprintf(stderr, "Line %d: missing data\n", line);
exit(1);
} else
type[typeidx++] = c;
break;
case REG_BINARY:
case REG_DWORD:
case REG_QWORD:
case REG_LINK:
case REG_RESOURCE_LIST:
case REG_FULL_RESOURCE_DESCRIPTOR:
case REG_RESOURCE_REQUIREMENTS_LIST:
if (c == '\n') {
switch (typeval) {
case REG_DWORD:
if (dataidx != 4) {
fprintf(stderr, "Line :%d: not a four byte DWORD\n", line);
exit(1);
}
swapbytes(data, dataidx);
break;
case REG_DWORD_BIG_ENDIAN:
if (dataidx != 4) {
fprintf(stderr, "Line :%d: not a four byte REG_DWORD_BIG_ENDIAN\n", line);
exit(1);
}
break;
case REG_QWORD:
if (dataidx != 8) {
fprintf(stderr, "Line :%d: not an eight byte QWORD\n", line);
exit(1);
}
swapbytes(data, dataidx);
break;
}
addkey:
addkey(name, typeval, data, dataidx);
nameidx = 0;
state = SNAME;
line++;
break;
} else if (isspace(c))
break;
data[dataidx] = hexval((unsigned char)c) << 4;
state = REG_BINARY2;
break;
case REG_BINARY2:
data[dataidx++] |= hexval((unsigned char)c);
state = REG_BINARY;
break;
case REG_SZ:
case REG_MULTI_SZ:
case REG_EXPAND_SZ:
if (c == '\n') {
data[dataidx] = '\0';
goto addkey;
} else if (c == '\\')
state = REG_SZ_BACK;
else
data[dataidx++] = c;
break;
case REG_SZ_BACK:
switch (c) {
case '\\': data[dataidx++] = '\\'; break;
case 'a': data[dataidx++] = '\a'; break;
case 'b': data[dataidx++] = '\b'; break;
case 'f': data[dataidx++] = '\f'; break;
case 't': data[dataidx++] = '\t'; break;
case 'r': data[dataidx++] = '\r'; break;
case 'n': data[dataidx++] = '\n'; break;
case 'v': data[dataidx++] = '\v'; break;
case '0': data[dataidx++] = '\0'; break;
case 'x': state = REG_SZ_HEX; hexcount = 0; break;
}
state = REG_SZ;
break;
case REG_SZ_HEX:
data[dataidx] = hexval((unsigned char)c) << 4;
state = REG_SZ_HEX2;
break;
case REG_SZ_HEX2:
data[dataidx++] |= hexval((unsigned char)c);
state = REG_SZ;
break;
case REG_NONE:
if (c == '\n')
goto addkey;
else {
fprintf(stderr, "Line %d: Unexpected data\n", line);
exit(1);
}
default:
assert(0);
}
}
}
JSDProperty*
jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* nameStr)
{
JSContext* cx = jsdc->dumbContext;
JSDProperty* jsdprop;
JSDProperty* iter = NULL;
JS::RootedObject obj(cx);
JS::RootedString name(cx, nameStr);
unsigned attrs = 0;
JSBool found;
JSPropertyDesc pd;
const jschar * nameChars;
size_t nameLen;
JS::RootedValue val(cx), nameval(cx);
JS::RootedId nameid(cx);
JSCompartment* oldCompartment = NULL;
if(!jsd_IsValueObject(jsdc, jsdval))
return NULL;
/* If we already have the prop, then return it */
while(NULL != (jsdprop = jsd_IterateProperties(jsdc, jsdval, &iter)))
{
JSString* propName = jsd_GetValueString(jsdc, jsdprop->name);
if(propName) {
int result;
if (JS_CompareStrings(cx, propName, name, &result) && !result)
return jsdprop;
}
JSD_DropProperty(jsdc, jsdprop);
}
/* Not found in property list, look it up explicitly */
if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
return NULL;
if (!(nameChars = JS_GetStringCharsZAndLength(cx, name, &nameLen)))
return NULL;
JS_BeginRequest(cx);
oldCompartment = JS_EnterCompartment(cx, obj);
JS_GetUCPropertyAttributes(cx, obj, nameChars, nameLen, &attrs, &found);
if (!found)
{
JS_LeaveCompartment(cx, oldCompartment);
JS_EndRequest(cx);
return NULL;
}
JS_ClearPendingException(cx);
if(!JS_GetUCProperty(cx, obj, nameChars, nameLen, val.address()))
{
if (JS_IsExceptionPending(cx))
{
if (!JS_GetPendingException(cx, &pd.value))
{
JS_LeaveCompartment(cx, oldCompartment);
JS_EndRequest(cx);
return NULL;
}
pd.flags = JSPD_EXCEPTION;
}
else
{
pd.flags = JSPD_ERROR;
pd.value = JSVAL_VOID;
}
}
else
{
pd.value = val;
}
JS_LeaveCompartment(cx, oldCompartment);
JS_EndRequest(cx);
nameval = STRING_TO_JSVAL(name);
if (!JS_ValueToId(cx, nameval, nameid.address()) ||
!JS_IdToValue(cx, nameid, &pd.id)) {
return NULL;
}
pd.spare = 0;
pd.alias = JSVAL_NULL;
pd.flags |= (attrs & JSPROP_ENUMERATE) ? JSPD_ENUMERATE : 0
| (attrs & JSPROP_READONLY) ? JSPD_READONLY : 0
| (attrs & JSPROP_PERMANENT) ? JSPD_PERMANENT : 0;
return _newProperty(jsdc, &pd, JSDPD_HINTED);
}
